BoghdadyJR/codesearch_python · Datasets at Hugging Face

text stringlengths 75 104k
def patStarLines(s0): '''make line pattern''' arr = np.zeros((s0,s0), dtype=np.uint8) col = 255 t = int(s0/100.) for pos in np.linspace(0,np.pi/2,15): p0 = int(round(np.sin(pos)s02)) p1 = int(round(np.cos(pos)s02)) cv2.line(arr,(0,0),(p0,p1), color=col, thickness=t, lineType=cv2.LINE_AA ) return arr.astype(float)
def patSiemensStar(s0, n=72, vhigh=255, vlow=0, antiasing=False): '''make line pattern''' arr = np.full((s0,s0),vlow, dtype=np.uint8) c = int(round(s0/2.)) s = 2np.pi/(2n) step = 0 for i in range(2n): p0 = round(c+np.sin(step)2s0) p1 = round(c+np.cos(step)2s0) step += s p2 = round(c+np.sin(step)2s0) p3 = round(c+np.cos(step)2*s0) pts = np.array(((c,c), (p0,p1), (p2,p3) ), dtype=int) cv2.fillConvexPoly(arr, pts, color=vhigh if i%2 else vlow, lineType=cv2.LINE_AA if antiasing else 0) arr[c,c]=0 return arr.astype(float)
def patText(s0): '''make text pattern''' arr = np.zeros((s0,s0), dtype=np.uint8) s = int(round(s0/100.)) p1 = 0 pp1 = int(round(s0/10.)) for pos0 in np.linspace(0,s0,10): cv2.putText(arr, 'helloworld', (p1,int(round(pos0))), cv2.FONT_HERSHEY_COMPLEX_SMALL, fontScale=s, color=255, thickness=s, lineType=cv2.LINE_AA ) if p1: p1 = 0 else: p1 = pp1 return arr.astype(float)
def removeSinglePixels(img): ''' img - boolean array remove all pixels that have no neighbour ''' gx = img.shape[0] gy = img.shape[1] for i in range(gx): for j in range(gy): if img[i, j]: found_neighbour = False for ii in range(max(0, i - 1), min(gx, i + 2)): for jj in range(max(0, j - 1), min(gy, j + 2)): if ii == i and jj == j: continue if img[ii, jj]: found_neighbour = True break if found_neighbour: break if not found_neighbour: img[i, j] = 0
def interpolateCircular2dStructuredIDW(grid, mask, kernel=15, power=2, fr=1, fphi=1, cx=0, cy=0): ''' same as interpolate2dStructuredIDW but calculation distance to neighbour using polar coordinates fr, fphi --> weight factors for radian and radius differences cx,cy -> polar center of the array e.g. middle->(sx//2+1,sy//2+1) ''' gx = grid.shape[0] gy = grid.shape[0] #FOR EVERY PIXEL for i in range(gx): for j in range(gy): if mask[i,j]: xmn = i-kernel if xmn < 0: xmn = 0 xmx = i+kernel if xmx > gx: xmx = gx ymn = j-kernel if ymn < 0: ymn = 0 ymx = j+kernel if ymx > gx: ymx = gy sumWi = 0.0 value = 0.0 #radius and radian to polar center: R = ((i-cx)2+(j-cy)2)0.5 PHI = atan2(j-cy, i-cx) #FOR EVERY NEIGHBOUR IN KERNEL for xi in range(xmn,xmx): for yi in range(ymn,ymx): if (xi != i or yi != j) and not mask[xi,yi]: nR = ((xi-cx)2+(yi-cy)2)0.5 dr = R - nR #average radius between both p: midR = 0.5(R+nR) #radian of neighbour p: nphi = atan2(yi-cy, xi-cx) #relative angle between both points: dphi = min((2np.pi) - abs(PHI - nphi), abs(PHI - nphi)) dphi=midR dist = ((frdr)*2+(fphidphi)2)2 wi = 1 / dist*(0.5power) sumWi += wi value += wi * grid[xi,yi] if sumWi: grid[i,j] = value / sumWi return grid
def interpolate2dStructuredCrossAvg(grid, mask, kernel=15, power=2): ''' ####### usefull if large empty areas need to be filled ''' vals = np.empty(shape=4, dtype=grid.dtype) dist = np.empty(shape=4, dtype=np.uint16) weights = np.empty(shape=4, dtype=np.float32) valid = np.empty(shape=4, dtype=bool) return _calc(grid, mask, power, kernel, vals, dist, weights, valid)
def growPositions(ksize): ''' return all positions around central point (0,0) for a given kernel size positions grow from smallest to biggest distances returns [positions] and [distances] from central cell ''' i = ksize2+1 kk = np.ones( (i, i), dtype=bool) x,y = np.where(kk) pos = np.empty(shape=(i,i,2), dtype=int) pos[:,:,0]=x.reshape(i,i)-ksize pos[:,:,1]=y.reshape(i,i)-ksize dist = np.fromfunction(lambda x,y: ((x-ksize)2 +(y-ksize)2)*0.5, (i,i)) pos = np.dstack( np.unravel_index( np.argsort(dist.ravel()), (i, i)))[0,1:] pos0 = pos[:,0] pos1 = pos[:,1] return pos-ksize, dist[pos0, pos1]
def qImageToArray(qimage, dtype = 'array'): """Convert QImage to numpy.ndarray. The dtype defaults to uint8 for QImage.Format_Indexed8 or `bgra_dtype` (i.e. a record array) for 32bit color images. You can pass a different dtype to use, or 'array' to get a 3D uint8 array for color images.""" result_shape = (qimage.height(), qimage.width()) temp_shape = (qimage.height(), qimage.bytesPerLine() * 8 // qimage.depth()) if qimage.format() in (QtGui.QImage.Format_ARGB32_Premultiplied, QtGui.QImage.Format_ARGB32, QtGui.QImage.Format_RGB32): if dtype == 'rec': dtype = np.dtype({'b': (np.uint8, 0), 'g': (np.uint8, 1), 'r': (np.uint8, 2), 'a': (np.uint8, 3)}) elif dtype == 'array': dtype = np.uint8 result_shape += (4, ) temp_shape += (4, ) elif qimage.format() == QtGui.QImage.Format_Indexed8: dtype = np.uint8 else: raise ValueError("qimage2numpy only supports 32bit and 8bit images") # FIXME: raise error if alignment does not match buf = qimage.bits().asstring(qimage.byteCount()) result = np.frombuffer(buf, dtype).reshape(temp_shape) if result_shape != temp_shape: result = result[:,:result_shape[1]] if qimage.format() == QtGui.QImage.Format_RGB32 and dtype == np.uint8: #case byteorder == 'little' result = result[...,:3] #byteorder == 'big' -> get ARGB result = result[...,::-1] return result
def varYSizeGaussianFilter(arr, stdyrange, stdx=0, modex='wrap', modey='reflect'): ''' applies gaussian_filter on input array but allowing variable ksize in y stdyrange(int) -> maximum ksize - ksizes will increase from 0 to given value stdyrange(tuple,list) -> minimum and maximum size as (mn,mx) stdyrange(np.array) -> all different ksizes in y ''' assert arr.ndim == 2, 'only works on 2d arrays at the moment' s0 = arr.shape[0] #create stdys: if isinstance(stdyrange, np.ndarray): assert len(stdyrange)==s0, '[stdyrange] needs to have same length as [arr]' stdys = stdyrange else: if type(stdyrange) not in (list, tuple): stdyrange = (0,stdyrange) mn,mx = stdyrange stdys = np.linspace(mn,mx,s0) #prepare array for convolution: kx = int(stdx2.5) kx += 1-kx%2 ky = int(mx2.5) ky += 1-ky%2 arr2 = extendArrayForConvolution(arr, (kx, ky), modex, modey) #create convolution kernels: inp = np.zeros((ky,kx)) inp[ky//2, kx//2] = 1 kernels = np.empty((s0,ky,kx)) for i in range(s0): stdy = stdys[i] kernels[i] = gaussian_filter(inp, (stdy,stdx)) out = np.empty_like(arr) _2dConvolutionYdependentKernel(arr2, out, kernels) return out
def numbaGaussian2d(psf, sy, sx): ''' 2d Gaussian to be used in numba code ''' ps0, ps1 = psf.shape c0,c1 = ps0//2, ps1//2 ssx = 2sx2 ssy = 2sy2 for i in range(ps0): for j in range(ps1): psf[i,j]=exp( -( (i-c0)2/ssy +(j-c1)**2/ssx) ) psf/=psf.sum()
def estimateBackgroundLevel(img, image_is_artefact_free=False, min_rel_size=0.05, max_abs_size=11): ''' estimate background level through finding the most homogeneous area and take its average min_size - relative size of the examined area ''' s0,s1 = img.shape[:2] s = min(max_abs_size, int(max(s0,s1)min_rel_size)) arr = np.zeros(shape=(s0-2s, s1-2s), dtype=img.dtype) #fill arr: _spatialStd(img, arr, s) #most homogeneous area: i,j = np.unravel_index(arr.argmin(), arr.shape) sub = img[int(i+0.5s):int(i+s1.5), int(j+s0.5):int(j+s*1.5)] return np.median(sub)
def EL_Si_module(): ''' returns angular dependent EL emissivity of a PV module calculated of nanmedian(persp-corrected EL module/reference module) published in K. Bedrich: Quantitative Electroluminescence Measurement on PV devices PhD Thesis, 2017 ''' arr = np.array([ [2.5, 1.00281 ], [7.5, 1.00238 ], [12.5, 1.00174], [17.5, 1.00204 ], [22.5, 1.00054 ], [27.5, 0.998255], [32.5, 0.995351], [37.5, 0.991246], [42.5, 0.985304], [47.5, 0.975338], [52.5, 0.960455], [57.5, 0.937544], [62.5, 0.900607], [67.5, 0.844636], [72.5, 0.735028], [77.5, 0.57492 ], [82.5, 0.263214], [87.5, 0.123062] ]) angles = arr[:,0] vals = arr[:,1] vals[vals>1]=1 return angles, vals
def TG_glass(): ''' reflected temperature for 250DEG Glass published in IEC 62446-3 TS: Photovoltaic (PV) systems - Requirements for testing, documentation and maintenance - Part 3: Outdoor infrared thermography of photovoltaic modules and plants p Page 12 ''' vals = np.array([(80,0.88), (75,0.88), (70,0.88), (65,0.88), (60,0.88), (55,0.88), (50,0.87), (45,0.86), (40,0.85), (35,0.83), (30,0.80), (25,0.76), (20,0.7), (15,0.60), (10,0.44)]) #invert angle reference: vals[:,0]=90-vals[:,0] #make emissivity relative: vals[:,1]/=vals[0,1] return vals[:,0], vals[:,1]
def sensitivity(imgs, bg=None): ''' Extract pixel sensitivity from a set of homogeneously illuminated images This method is detailed in Section 5 of: --- K.Bedrich, M.Bokalic et al.: ELECTROLUMINESCENCE IMAGING OF PV DEVICES: ADVANCED FLAT FIELD CALIBRATION,2017 --- ''' bg = getBackground(bg) for n, i in enumerate(imgs): i = imread(i, dtype=float) i -= bg smooth = fastMean(median_filter(i, 3)) i /= smooth if n == 0: out = i else: out += i out /= (n + 1) return out
def navierStokes2d(u, v, p, dt, nt, rho, nu, boundaryConditionUV, boundardConditionP, nit=100): ''' solves the Navier-Stokes equation for incompressible flow one a regular 2d grid u,v,p --> initial velocity(u,v) and pressure(p) maps dt --> time step nt --> number of time steps to caluclate rho, nu --> material constants nit --> number of iteration to solve the pressure field ''' #next u, v, p maps: un = np.empty_like(u) vn = np.empty_like(v) pn = np.empty_like(p) #poisson equation ==> laplace term = b[source term] b = np.zeros_like(p) ny,nx = p.shape #cell size: dx = 2 / (nx - 1) dy = 2 / (ny - 1) #next time step: for _ in range(nt): un[:] = u vn[:] = v #pressure _buildB(b, rho, dt, u, v, dx, dy) for _ in range(nit): _pressurePoisson(p, pn, dx, dy, b) boundardConditionP(p) #UV _calcUV(u, v, un, p,vn, dt, dx, dy, rho, nu) boundaryConditionUV(u,v) return u, v, p
def shiftImage(u, v, t, img, interpolation=cv2.INTER_LANCZOS4): ''' remap an image using velocity field ''' ny,nx = u.shape sy, sx = np.mgrid[:float(ny):1,:float(nx):1] sx += ut sy += vt return cv2.remap(img.astype(np.float32), (sx).astype(np.float32), (sy).astype(np.float32), interpolation)
def addNoise(img, snr=25, rShot=0.5): ''' adds Gaussian (thermal) and shot noise to [img] [img] is assumed to be noise free [rShot] - shot noise ratio relative to all noise ''' s0, s1 = img.shape[:2] m = img.mean() if np.isnan(m): m = np.nanmean(img) assert m != 0, 'image mean cannot be zero' img = img / m noise = np.random.normal(size=s0 * s1).reshape(s0, s1) if rShot > 0: noise = (rShot img*0.5 + 1) noise /= np.nanstd(noise) noise[np.isnan(noise)] = 0 return m (img + noise / snr)
def coarseMaximum(arr, shape): ''' return an array of [shape] where every cell equals the localised maximum of the given array [arr] at the same (scalled) position ''' ss0, ss1 = shape s0, s1 = arr.shape pos0 = linspace2(0, s0, ss0, dtype=int) pos1 = linspace2(0, s1, ss1, dtype=int) k0 = pos0[0] k1 = pos1[0] out = np.empty(shape, dtype=arr.dtype) _calc(arr, out, pos0, pos1, k0, k1, ss0, ss1) return out
def angleOfView(XY, shape=None, a=None, f=None, D=None, center=None): ''' Another vignetting equation from: M. Koentges, M. Siebert, and D. Hinken, "Quantitative analysis of PV-modules by electroluminescence images for quality control" 2009 f --> Focal length D --> Diameter of the aperture BOTH, D AND f NEED TO HAVE SAME UNIT [PX, mm ...] a --> Angular aperture center -> optical center [y,x] ''' if a is None: assert f is not None and D is not None #https://en.wikipedia.org/wiki/Angular_aperture a = 2np.arctan2(D/2,f) x,y = XY try: c0,c1 = center except: s0,s1 = shape c0,c1 = s0/2, s1/2 rx = (x-c0)2 ry = (y-c1)2 return 1 / (1+np.tan(a)((rx+ry)/c0))**0.5
def angleOfView2(x,y, b, x0=None,y0=None): ''' Corrected AngleOfView equation by Koentges (via mail from 14/02/2017) b --> distance between the camera and the module in m x0 --> viewable with in the module plane of the camera in m y0 --> viewable height in the module plane of the camera in m x,y --> pixel position [m] from top left ''' if x0 is None: x0 = x[-1,-1] if y0 is None: y0 = y[-1,-1] return np.cos( np.arctan( np.sqrt( ( (x-x0/2)2+(y-y0/2)2 ) ) /b ) )
def gridLinesFromVertices(edges, nCells, subgrid=None, dtype=float): """ ###TODO REDO TXT OPTIONAL: subgrid = ([x],[y]) --> relative positions e.g. subgrid = ( (0.3,0.7), () ) --> two subgrid lines in x - nothing in y Returns: horiz,vert -> arrays of (x,y) poly-lines if subgrid != None, Returns: horiz,vert, subhoriz, subvert ####### creates a regular 2d grid from given edge points (4(x0,y0)) and number of cells in x and y Returns: tuple(4lists): horizontal and vertical lines as (x0,y0,x1,y1) """ nx, ny = nCells y, x = np.mgrid[0.:ny + 1, 0.:nx + 1] src = np.float32([[0, 0], [nx, 0], [nx, ny], [0, ny]]) dst = sortCorners(edges).astype(np.float32) homography = cv2.getPerspectiveTransform(src, dst) pts = np.float32((x.flatten(), y.flatten())).T pts = pts.reshape(1, pts.shape) pts2 = cv2.perspectiveTransform(pts, homography)[0] horiz = pts2.reshape(ny + 1, nx + 1, 2) vert = np.swapaxes(horiz, 0, 1) subh, subv = [], [] if subgrid is not None: sh, sv = subgrid if len(sh): subh = np.empty(shape=(ny * len(sh), nx + 1, 2), dtype=np.float32) last_si = 0 for n, si in enumerate(sh): spts = pts[:, :-(nx + 1)] spts[..., 1] += si - last_si last_si = si spts2 = cv2.perspectiveTransform(spts, homography)[0] subh[n::len(sh)] = spts2.reshape(ny, nx + 1, 2) if len(sv): subv = np.empty(shape=(ny + 1, nx * len(sv), 2), dtype=np.float32) last_si = 0 sspts = pts.reshape(1, ny + 1, nx + 1, 2) sspts = sspts[:, :, :-1] sspts = sspts.reshape(1, (ny + 1) * nx, 2) for n, si in enumerate(sv): sspts[..., 0] += si - last_si last_si = si spts2 = cv2.perspectiveTransform(sspts, homography)[0] subv[:, n::len(sv)] = spts2.reshape(ny + 1, nx, 2) subv = np.swapaxes(subv, 0, 1) return [horiz, vert, subh, subv]
def MTF50(self, MTFx,MTFy): ''' return object resolution as [line pairs/mm] where MTF=50% see http://www.imatest.com/docs/sharpness/ ''' if self.mtf_x is None: self.MTF() f = UnivariateSpline(self.mtf_x, self.mtf_y-0.5) return f.roots()[0]
def MTF(self, px_per_mm): ''' px_per_mm = cam_resolution / image_size ''' res = 100 #numeric resolution r = 4 #range +-rstd #size of 1 px: px_size = 1 / px_per_mm #standard deviation of the point-spread-function (PSF) as normal distributed: std = self.stdpx_size #transform standard deviation from [px] to [mm] x = np.linspace(-rstd,rstd, res) #line spread function: lsf = self.gaussian1d(x, 1, 0, std) #MTF defined as Fourier transform of the line spread function: #abs() because result is complex y = abs(np.fft.fft(lsf)) #normalize fft so that max = 1 y /= np.max(y) #step length between xn and xn+1 dstep = r*std/res # Fourier frequencies - here: line pairs(cycles) per mm freq = np.fft.fftfreq(lsf.size, dstep) #limit mtf between [0-px_per_mm]: i = np.argmax(freq>px_per_mm) self.mtf_x = freq[:i] self.mtf_y = y[:i] return self.mtf_x, self.mtf_y
def uncertaintyMap(self, psf, method='convolve', fitParams=None): ''' return the intensity based uncertainty due to the unsharpness of the image as standard deviation method = ['convolve' , 'unsupervised_wiener'] latter one also returns the reconstructed image (deconvolution) ''' #ignore background: #img[img<0]=0 ###noise should not influence sharpness uncertainty: ##img = median_filter(img, 3) # decrease noise in order not to overestimate result: img = scaleSignal(self.img, fitParams=fitParams) if method == 'convolve': #print 'convolve' blurred = convolve2d(img, psf, 'same') m = abs(img-blurred) / abs(img + blurred) m = np.nan_to_num(m) m=self.std2 m[m>1]=1 self.blur_distortion = m np.save('blurred', blurred) return m else: restored = unsupervised_wiener(img, psf)[0] m = abs(img-restored) / abs(img + restored) m = np.nan_to_num(m) m=self.std**2 m[m>1]=1 self.blur_distortion = m return m, restored
def stdDev(self): ''' get the standard deviation from the PSF is evaluated as 2d Gaussian ''' if self._corrPsf is None: self.psf() p = self._corrPsf.copy() mn = p.min() p[p<0.05*p.max()] = mn p-=mn p/=p.sum() x,y = self._psfGridCoords() x = x.flatten() y = y.flatten() guess = (1,1,0) param, _ = curve_fit(self._fn, (x,y), p.flatten(), guess) self._fitParam = param stdx,stdy = param[:2] self._std = (stdx+stdy) / 2 return self._std
def interpolate2dStructuredIDW(grid, mask, kernel=15, power=2, fx=1, fy=1): ''' replace all values in [grid] indicated by [mask] with the inverse distance weighted interpolation of all values within px+-kernel [power] -> distance weighting factor: 1/distance*[power] ''' weights = np.empty(shape=((2kernel+1,2kernel+1))) for xi in range(-kernel,kernel+1): for yi in range(-kernel,kernel+1): dist = ((fxxi)*2+(fyyi)2) if dist: weights[xi+kernel,yi+kernel] = 1 / dist(0.5*power) return _calc(grid, mask, kernel, weights)
def temporalSignalStability(imgs, times, down_scale_factor=1): ''' (Electroluminescence) signal is not stable over time especially next to cracks. This function takes a set of images and returns parameters, needed to transform uncertainty to other exposure times using [adjustUncertToExposureTime] return [signal uncertainty] obtained from linear fit to [imgs] [average event length] [ascent],[offset] of linear fit -------- [imgs] --> corrected EL images captured in sequence [times] --> absolute measurement times of all [imgs] e.g. every image was taken every 60 sec, then times=60,120,180... [down_scale_factor] --> down scale [imgs] to speed up process ------- More information can be found at ... ---- K.Bedrich: Quantitative Electroluminescence Imaging, PhD Thesis, 2017 Subsection 5.1.4.3: Exposure Time Dependency ---- ''' imgs = np.asarray(imgs) s0, s1, s2 = imgs.shape #down scale imgs to speed up process: if down_scale_factor > 1: s1 //= down_scale_factor s2 //= down_scale_factor imgs2 = np.empty(shape=(s0, s1, s2)) for n, c in enumerate(imgs): imgs2[n] = cv2.resize(c, (s2, s1), interpolation=cv2.INTER_AREA) imgs = imgs2 # linear fit for every point in image set: ascent, offset, error = linRegressUsingMasked2dArrays( times, imgs, calcError=True) # functionally obtained [imgs]: fn_imgs = np.array([offset + t * ascent for t in times]) #difference between [imgs] for fit result: diff = imgs - fn_imgs diff = median_filter(diff, 5) error_t = np.tile(error, (s0, 1, 1)) # find events: evt = (np.abs(diff) > 0.5 * error_t) # calc average event length: avlen = _calcAvgLen(evt, np.empty(shape=evt.shape[1:])) #cannot calc event length smaller exposure time, so: i = avlen == 0 avlen = maskedFilter(avlen, mask=i, fn='mean', ksize=7, fill_mask=False) # remove single px: i = maximum_filter(i, 3) avlen[i] = 0 avlen = maximum_filter(avlen, 3) i = avlen == 0 avlen = median_filter(avlen, 3) avlen[i] = 0 return error, avlen, ascent, offset
def vignettingFromSpotAverage( images, bgImages=None, averageSpot=True, thresh=None): ''' [images] --> list of images containing small bright spots generated by the same device images at different positions within image plane depending on the calibrated waveband the device can be a LCD display or PV 1-cell mini module This method is referred as 'Method B' in --- K.Bedrich, M.Bokalic et al.: ELECTROLUMINESCENCE IMAGING OF PV DEVICES: ADVANCED FLAT FIELD CALIBRATION,2017 --- Args: averageSpot(bool): True: take only the average intensity of each spot thresh(float): marks the minimum spot value (estimated with Otsus method otherwise) Returns: * array to be post processed * image mask containing valid positions ''' fitimg, mask = None, None mx = 0 for c, img in enumerate(images): print('%s/%s' % (c + 1, len(images))) if c == 0: avgBg = getBackground2(bgImages, img) img = imread(img, dtype=float) img -= avgBg # init: if fitimg is None: fitimg = np.zeros_like(img) mask = np.zeros_like(img, dtype=bool) # find spot: if thresh is None: t = threshold_otsu(img) else: t = thresh # take brightest spot spots, n = label(minimum_filter(img > t, 3), background=0, return_num=True) spot_sizes = [(spots == i).sum() for i in range(1, n + 1)] try: spot = (spots == np.argmax(spot_sizes) + 1) except ValueError: print("couldn't find spot in image") continue if averageSpot: spot = np.rint(center_of_mass(spot)).astype(int) mx2 = img[spot].max() else: mx2 = img[spot].mean() fitimg[spot] = img[spot] mask[spot] = 1 if mx2 > mx: mx = mx2 # scale [0...1]: fitimg /= mx return fitimg, mask
def simulateSytematicError(N_SAMPLES=5, N_IMAGES=10, SHOW_DETECTED_PATTERN=True, # GRAYSCALE=False, HEIGHT=500, PLOT_RESULTS=True, PLOT_ERROR_ARRAY=True, CAMERA_PARAM=None, PERSPECTIVE=True, ROTATION=True, RELATIVE_PATTERN_SIZE=0.5, POSITION=True, NOISE=25, BLUR=(3, 3), PATTERNS=None): ''' Simulates a lens calibration using synthetic images * images are rendered under the given HEIGHT resolution * noise and smoothing is applied * perspective and position errors are applied * images are deformed using the given CAMERA_PARAM * the detected camera parameters are used to calculate the error to the given ones simulation ----------- N_IMAGES -> number of images to take for a camera calibration N_SAMPLES -> number of camera calibrations of each pattern type output -------- SHOW_DETECTED_PATTERN: print each image and detected pattern to screen PLOT_RESULTS: plot boxplots of the mean error and std of the camera parameters PLOT_ERROR_ARRAY: plot position error for the lens correction pattern -------- this simulation tests the openCV standard patterns: chess board, asymmetric and symmetric circles GRAYSCALE: whether to load the pattern as gray scale RELATIVE_PATTERN_SIZE: the relative size of the pattern within the image (0.4->40%) PERSPECTIVE: [True] -> enable perspective distortion ROTATION: [True] -> enable rotation of the pattern BLUR: False or (sizex,sizey), like (3,3) CAMERA_PARAM: camera calibration parameters as [fx,fy,cx,cy,k1,k2,k3,p1,p2] ''' print( 'calculate systematic error of the implemented calibration algorithms') # LOCATION OF PATTERN IMAGES folder = MEDIA_PATH if PATTERNS is None: PATTERNS = ('Chessboard', 'Asymmetric circles', 'Symmetric circles') patterns = OrderedDict(( # n of inner corners ('Chessboard', ((6, 9), 'chessboard_pattern_a3.svg')), ('Asymmetric circles', ((4, 11), 'acircles_pattern_a3.svg')), ('Symmetric circles', ((8, 11), 'circles_pattern_a3.svg')), )) # REMOVE PATTERNS THAT ARE NOT TO BE TESTED: [patterns.pop(key) for key in patterns if key not in PATTERNS] if SHOW_DETECTED_PATTERN: cv2.namedWindow('Pattern', cv2.WINDOW_NORMAL) # number of positive detected patterns: success = [] # list[N_SAMPLES] of random camera parameters fx, fy, cx, cy, k1, k2, k3, p1, p2 = [], [], [], [], [], [], [], [], [] # list[Method, N_SAMPLES] of given-detected parameters: errl, fxl, fyl, cxl, cyl, k1l, k2l, k3l, p1l, p2l = [ ], [], [], [], [], [], [], [], [], [] # list[Method, N_SAMPLES] of magnitude(difference of displacement vector # array): dxl = [] dyl = [] # maintain aspect ratio of din a4, a3...: aspect_ratio_DIN = 2.0*0.5 width = int(round(HEIGHT / aspect_ratio_DIN)) if CAMERA_PARAM is None: CAMERA_PARAM = [ HEIGHT, HEIGHT, HEIGHT / 2, width / 2, 0.0, 0.01, 0.1, 0.01, 0.001] # ???CREATE N DIFFERENT RANDOM LENS ERRORS: for n in range(N_SAMPLES): # TODO: RANDOMIZE CAMERA ERROR?? fx.append(CAMERA_PARAM[0]) # np.random.uniform(1, 2) ) fy.append(CAMERA_PARAM[1]) # * np.random.uniform(1, 2) ) cx.append(CAMERA_PARAM[2]) # * np.random.uniform(0.9, 1.1) ) cy.append(CAMERA_PARAM[3]) # * np.random.uniform(0.9, 1.1) ) k1.append(CAMERA_PARAM[4]) # + np.random.uniform(-1, 1)0.1) k2.append(CAMERA_PARAM[5]) # + np.random.uniform(-1, 1)0.01) p1.append(CAMERA_PARAM[6]) # + np.random.uniform(0, 1)0.1) p2.append(CAMERA_PARAM[7]) # + np.random.uniform(0, 1)0.01) k3.append(CAMERA_PARAM[8]) # + np.random.uniform(0, 1)0.001) L = LensDistortion() # FOR EVERY METHOD: for method, (board_size, filename) in patterns.items(): f = folder.join(filename) # LOAD THE SVG FILE, AND SAVE IT WITH NEW RESOLUTION: svg = QtSvg.QSvgRenderer(f) image = QtGui.QImage(width 4, HEIGHT * 4, QtGui.QImage.Format_ARGB32) image.fill(QtCore.Qt.white) # Get QPainter that paints to the image painter = QtGui.QPainter(image) svg.render(painter) # Save, image format based on file extension # f = "rendered.png" # image.save(f) # # if GRAYSCALE: # img = cv2.imread(f, cv2.IMREAD_GRAYSCALE) # else: # img = cv2.imread(f) img = qImageToArray(image) success.append([]) fxl.append([]) errl.append([]) fyl.append([]) cxl.append([]) cyl.append([]) k1l.append([]) k2l.append([]) k3l.append([]) p1l.append([]) p2l.append([]) dxl.append([]) dyl.append([]) imgHeight, imgWidth = img.shape[0], img.shape[1] for n in range(N_SAMPLES): L.calibrate(board_size, method) print('SET PARAMS:', fx[n], fy[n], cx[n], cy[n], k1[n], k2[n], k3[n], p1[n], p2[n]) L.setCameraParams( fx[n], fy[n], cx[n], cy[n], k1[n], k2[n], k3[n], p1[n], p2[n]) L._coeffs['shape'] = (imgHeight, imgWidth) hw = imgWidth * 0.5 hh = imgHeight * 0.5 for m in range(N_IMAGES): pts1 = np.float32([[hw, hh + 100], [hw - 100, hh - 100], [hw + 100, hh - 100]]) pts2 = pts1.copy() if ROTATION: rotatePolygon(pts2, np.random.randint(0, 2 * np.pi)) if PERSPECTIVE: # CREATE A RANDOM PERSPECTIVE: pts2 += np.random.randint(-hw * 0.05, hh * 0.05, size=(3, 2)) # MAKE SURE THAT THE PATTERN IS FULLY WITHIN THE IMAGE: pts2 = RELATIVE_PATTERN_SIZE # MOVE TO THE CENTER pts2[:, 0] += hw (1 - RELATIVE_PATTERN_SIZE) pts2[:, 1] += hh * (1 - RELATIVE_PATTERN_SIZE) if POSITION: f = ((2 * np.random.rand(2)) - 1) pts2[:, 0] += hw * 0.7 * f[0] * (1 - RELATIVE_PATTERN_SIZE) pts2[:, 1] += hh * 0.7 * f[1] * (1 - RELATIVE_PATTERN_SIZE) # EXEC PERSPECTICE, POSITION, ROTATION: M = cv2.getAffineTransform(pts1, pts2) img_warped = cv2.warpAffine( img, M, (imgWidth, imgHeight), borderValue=(230, 230, 230)) # DOWNSCALE IMAGE AGAIN - UPSCALING AND DOWNSCALING SHOULD BRING THE ERRROR # WARPING DOWN img_warped = cv2.resize(img_warped, (width, HEIGHT)) # CREATE THE LENS DISTORTION: mapx, mapy = L.getDistortRectifyMap(width, HEIGHT) # print 664, mapx.shape img_distorted = cv2.remap( img_warped, mapx, mapy, cv2.INTER_LINEAR, borderValue=(230, 230, 230)) # img_distorted[img_distorted==0]=20 # img_distorted[img_distorted>100]=230 if BLUR: img_distorted = cv2.blur(img_distorted, BLUR) if NOISE: # soften, black and white more gray, and add noise img_distorted = img_distorted.astype(np.int16) img_distorted += (np.random.rand(img_distorted.shape) NOISE).astype(img_distorted.dtype) img_distorted = np.clip( img_distorted, 0, 255).astype(np.uint8) # plt.imshow(img_distorted) # plt.show() found = L.addImg(img_distorted) if SHOW_DETECTED_PATTERN and found: img_distorted = L.drawChessboard(img_distorted) cv2.imshow('Pattern', img_distorted) cv2.waitKey(1) success[-1].append(L.findCount) try: L._coeffs = None errl[-1].append(L.coeffs['reprojectionError']) L.correct(img_distorted) c = L.getCameraParams() print('GET PARAMS:', c) fxl[-1].append(fx[n] - c[0]) fyl[-1].append(fy[n] - c[1]) cxl[-1].append(cx[n] - c[2]) cyl[-1].append(cy[n] - c[3]) k1l[-1].append(k1[n] - c[4]) k2l[-1].append(k2[n] - c[5]) k3l[-1].append(k3[n] - c[6]) p1l[-1].append(p1[n] - c[7]) p2l[-1].append(p2[n] - c[8]) if PLOT_ERROR_ARRAY: dx = (mapx - L.mapx) / 2 dy = (mapy - L.mapy) / 2 dxl[-1].append(dx) dyl[-1].append(dy) except NothingFound: print( "Couldn't create a calibration because no patterns were detected") del painter # AVERAGE SAMPLES AND GET STD dx_std, dx_mean = [], [] dy_std, dy_mean = [], [] mag = [] std = [] for patterndx, patterndy in zip(dxl, dyl): x = np.mean(patterndx, axis=0) dx_mean.append(x) y = np.mean(patterndy, axis=0) dy_mean.append(y) x = np.std(patterndx, axis=0) mag.append((x2 + y2)0.5) dx_std.append(x) y = np.std(patterndy, axis=0) dy_std.append(y) std.append((x2 + y2)0.5) # PLOT p = len(patterns) if PLOT_RESULTS: fig, axs = plt.subplots(nrows=2, ncols=5) axs = np.array(axs).ravel() for ax, typ, tname in zip(axs, (success, fxl, fyl, cxl, cyl, k1l, k2l, k3l, p1l, p2l), ('Success rate', 'fx', 'fy', 'cx', 'cy', 'k1', 'k2', 'k3', 'p1', 'p2') ): ax.set_title(tname) # , showmeans=True, meanline=True)#labels=patterns.keys()) ax.boxplot(typ, notch=0, sym='+', vert=1, whis=1.5) # , ha=ha[n]) ax.set_xticklabels(patterns.keys(), rotation=40, fontsize=8) if PLOT_ERROR_ARRAY: mmin = np.min(mag) mmax = np.max(mag) smin = np.min(std) smax = np.max(std) plt.figure() for n, pattern in enumerate(patterns.keys()): plt.subplot(int('2%s%s' % (p, n + 1)), axisbg='g') plt.title(pattern) plt.imshow(mag[n], origin='upper', vmin=mmin, vmax=mmax) if n == p - 1: plt.colorbar(label='Average') plt.subplot(int('2%s%s' % (p, n + p + 1)), axisbg='g') plt.title(pattern) plt.imshow(std[n], origin='upper', vmin=smin, vmax=smax) if n == p - 1: plt.colorbar(label='Standard deviation') fig = plt.figure() fig.suptitle('Individually scaled') for n, pattern in enumerate(patterns.keys()): # downscale - show max 30 arrows each dimension sy, sx = dx_mean[n].shape ix = int(sx / 15) if ix < 1: ix = 1 iy = int(sy / 15) if iy < 1: iy = 1 Y, X = np.meshgrid(np.arange(0, sy, iy), np.arange(0, sx, ix)) plt.subplot(int('2%s%s' % (p, n + 1)), axisbg='g') plt.title(pattern) plt.imshow(mag[n], origin='upper') plt.colorbar() plt.quiver( X, Y, dy_mean[n][::ix, ::iy] * 20, dx_mean[n][::ix, ::iy] * 20) plt.subplot(int('2%s%s' % (p, n + p + 1)), axisbg='g') plt.title(pattern) plt.imshow(std[n], origin='upper') plt.colorbar() # plt.quiver(X,Y,dx_std[n][::ix,::iy]50, dy_std[n][::ix,::iy]10) ############################################# fig = plt.figure() fig.suptitle('Spatial uncertainty + deflection') for n, pattern in enumerate(patterns.keys()): L.calibrate(board_size, method) # there is alot of additional calc thats not necassary: L.setCameraParams( fx[0], fy[0], cx[0], cy[0], k1[0], k2[0], k3[0], p1[0], p2[0]) L._coeffs['shape'] = (imgHeight, imgWidth) L._coeffs['reprojectionError'] = np.mean(errl[n]) # deflection_x, deflection_y = L.getDeflection(width, HEIGHT) # deflection_x += dx_mean[n] # deflection_y += dy_mean[n] ux, uy = L.standardUncertainties() plt.subplot(int('2%s%s' % (p, n + 1)), axisbg='g') plt.title(pattern) plt.imshow(mag[n], origin='upper') plt.colorbar() # DEFLECTION plt.subplot(int('2%s%s' % (p, n + p + 1)), axisbg='g') plt.title(pattern) plt.imshow(np.linalg.norm([ux, uy], axis=0), origin='upper') plt.colorbar() # DEFL: VECTORS # downscale - show max 30 arrows each dimension sy, sx = dx_mean[n].shape ix = int(sx / 15) if ix < 1: ix = 1 iy = int(sy / 15) if iy < 1: iy = 1 Y, X = np.meshgrid(np.arange(0, sy, iy), np.arange(0, sx, ix)) plt.quiver(X, Y, ux[::ix, ::iy] * 20, uy[::ix, ::iy] * 20) if PLOT_ERROR_ARRAY or PLOT_RESULTS: plt.show() return dx_mean, dy_mean
def plotSet(imgDir, posExTime, outDir, show_legend, show_plots, save_to_file, ftype): ''' creates plots showing both found GAUSSIAN peaks, the histogram, a smoothed histogram from all images within [imgDir] posExTime - position range of the exposure time in the image name e.g.: img_30s.jpg -> (4,5) outDir - dirname to save the output images show_legend - True/False show_plots - display the result on screen save_to_file - save the result to file ftype - file type of the output images ''' xvals = [] hist = [] peaks = [] exTimes = [] max_border = 0 if not imgDir.exists(): raise Exception("image dir doesn't exist") for n, f in enumerate(imgDir): print(f) try: # if imgDir.join(f).isfile(): img = imgDir.join(f) s = FitHistogramPeaks(img) xvals.append(s.xvals) hist.append(s.yvals) # smoothedHist.append(s.yvals2) peaks.append(s.fitValues()) if s.border() > max_border: max_border = s.plotBorder() exTimes.append(float(f[posExTime[0]:posExTime[1] + 1])) except: pass nx = 2 ny = int(len(hist) // nx) + len(hist) % nx fig, ax = plt.subplots(ny, nx) # flatten 2d-ax list: if nx > 1: ax = [list(i) for i in zip(ax)] # transpose 2d-list axx = [] for xa in ax: for ya in xa: axx.append(ya) ax = axx for x, h, p, e, a in zip(xvals, hist, peaks, exTimes, ax): a.plot(x, h, label='histogram', thickness=3) # l1 = a.plot(x, s, label='smoothed') for n, pi in enumerate(p): l2 = a.plot(x, pi, label='peak %s' % n, thickness=6) a.set_xlim(xmin=0, xmax=max_border) a.set_title('%s s' % e) # plt.setp([l1,l2], linewidth=2)#, linestyle='--', color='r') # set # both to dashed l1 = ax[0].legend() # loc='upper center', bbox_to_anchor=(0.7, 1.05), l1.draw_frame(False) plt.xlabel('pixel value') plt.ylabel('number of pixels') fig = plt.gcf() fig.set_size_inches(7 nx, 3 * ny) if save_to_file: p = PathStr(outDir).join('result').setFiletype(ftype) plt.savefig(p, bbox_inches='tight') if show_plots: plt.show()
def flatFieldFromCloseDistance(imgs, bg_imgs=None): ''' Average multiple images of a homogeneous device imaged directly in front the camera lens. if [bg_imgs] are not given, background level is extracted from 1% of the cumulative intensity distribution of the averaged [imgs] This measurement method is referred as 'Method A' in --- K.Bedrich, M.Bokalic et al.: ELECTROLUMINESCENCE IMAGING OF PV DEVICES: ADVANCED FLAT FIELD CALIBRATION,2017 --- ''' img = imgAverage(imgs) bg = getBackground2(bg_imgs, img) img -= bg img = toGray(img) mx = median_filter(img[::10, ::10], 3).max() img /= mx return img
def flatFieldFromCloseDistance2(images, bgImages=None, calcStd=False, nlf=None, nstd=6): ''' Same as [flatFieldFromCloseDistance]. Differences are: ... single-time-effect removal included ... returns the standard deviation of the image average [calcStd=True] Optional: ----------- calcStd -> set to True to also return the standard deviation nlf -> noise level function (callable) nstd -> artefact needs to deviate more than [nstd] to be removed ''' if len(images) > 1: # start with brightest images def fn(img): img = imread(img) s0, s1 = img.shape[:2] # rough approx. of image brightness: return -img[::s0 // 10, ::s1 // 10].min() images = sorted(images, key=lambda i: fn(i)) avgBg = getBackground2(bgImages, images[1]) i0 = imread(images[0], dtype=float) - avgBg i1 = imread(images[1], dtype=float) - avgBg if nlf is None: nlf = oneImageNLF(i0, i1)[0] det = SingleTimeEffectDetection( (i0, i1), nlf, nStd=nstd, calcVariance=calcStd) for i in images[1:]: i = imread(i) # exclude erroneously darker areas: thresh = det.noSTE - nlf(det.noSTE) * nstd mask = i > thresh # filter STE: det.addImage(i, mask) ma = det.noSTE else: ma = imread(images[0], dtype=float) - avgBg # fast artifact free maximum: mx = median_filter(ma[::10, ::10], 3).max() if calcStd: return ma / mx, det.mma.var**0.5 / mx return ma / mx
def SNR_hinken(imgs, bg=0, roi=None): ''' signal-to-noise ratio (SNR) as mean(images) / std(images) as defined in Hinken et.al. 2011 (DOI: 10.1063/1.3541766) works on unloaded images no memory overload if too many images are given ''' mean = None M = len(imgs) if bg is not 0: bg = imread(bg)[roi] if roi is not None: bg = bg[roi] #calc mean: for i in imgs: img = imread(i).asfarray() if roi is not None: img = img[roi] img -= bg if mean is None: #init mean = np.zeros_like(img) std = np.zeros_like(img) mean += img del img mean /= M #calc std of mean: for i in imgs: img = imread(i).asfarray() if roi is not None: img = img[roi] img -= bg std += (mean - img)2 del img std = (std / M)0.5 return mean.mean() / std.mean()
def boolMasksToImage(masks): ''' Transform at maximum 8 bool layers --> 2d arrays, dtype=(bool,int) to one 8bit image ''' assert len(masks) <= 8, 'can only transform up to 8 masks into image' masks = np.asarray(masks, dtype=np.uint8) assert masks.ndim == 3, 'layers need to be stack of 2d arrays' return np.packbits(masks, axis=0)[0].T
def imageToBoolMasks(arr): '''inverse of [boolMasksToImage]''' assert arr.dtype == np.uint8, 'image needs to be dtype=uint8' masks = np.unpackbits(arr).reshape(*arr.shape, 8) return np.swapaxes(masks, 2, 0)
def calcAspectRatioFromCorners(corners, in_plane=False): ''' simple and better alg. than below in_plane -> whether object has no tilt, but only rotation and translation ''' q = corners l0 = [q[0, 0], q[0, 1], q[1, 0], q[1, 1]] l1 = [q[0, 0], q[0, 1], q[-1, 0], q[-1, 1]] l2 = [q[2, 0], q[2, 1], q[3, 0], q[3, 1]] l3 = [q[2, 0], q[2, 1], q[1, 0], q[1, 1]] a1 = line.length(l0) / line.length(l1) a2 = line.length(l2) / line.length(l3) if in_plane: # take aspect ration from more rectangular corner if (abs(0.5 * np.pi - abs(line.angle2(l0, l1))) < abs(0.5 * np.pi - abs(line.angle2(l2, l3)))): return a1 else: return a2 return 0.5 * (a1 + a2)
def putTextAlpha(img, text, alpha, org, fontFace, fontScale, color, thickness): # , lineType=None ''' Extends cv2.putText with [alpha] argument ''' x, y = cv2.getTextSize(text, fontFace, fontScale, thickness)[0] ox, oy = org imgcut = img[oy - y - 3:oy, ox:ox + x] if img.ndim == 3: txtarr = np.zeros(shape=(y + 3, x, 3), dtype=np.uint8) else: txtarr = np.zeros(shape=(y + 3, x), dtype=np.uint8) cv2.putText(txtarr, text, (0, y), fontFace, fontScale, color, thickness=thickness #, lineType=lineType ) cv2.addWeighted(txtarr, alpha, imgcut, 1, 0, imgcut, -1) return img
def fastMean(img, f=10, inplace=False): ''' for bigger ksizes it if often faster to resize an image rather than blur it... ''' s0,s1 = img.shape[:2] ss0 = int(round(s0/f)) ss1 = int(round(s1/f)) small = cv2.resize(img,(ss1,ss0), interpolation=cv2.INTER_AREA) #bigger k = {'interpolation':cv2.INTER_LINEAR} if inplace: k['dst']=img return cv2.resize(small,(s1,s0), **k)
def read(paths): """Build a file path from paths* and return the contents.""" try: f_name = os.path.join(*paths) with open(f_name, 'r') as f: return f.read() except IOError: print('%s not existing ... skipping' % f_name) return ''
def averageSameExpTimes(imgs_path): ''' average background images with same exposure time ''' firsts = imgs_path[:2] imgs = imgs_path[2:] for n, i in enumerate(firsts): firsts[n] = np.asfarray(imread(i)) d = DarkCurrentMap(firsts) for i in imgs: i = imread(i) d.addImg(i) return d.map()
def getLinearityFunction(expTimes, imgs, mxIntensity=65535, min_ascent=0.001, ): ''' returns offset, ascent of image(expTime) = offset + ascentexpTime ''' # TODO: calculate [min_ascent] from noise function # instead of having it as variable ascent, offset, error = linRegressUsingMasked2dArrays( expTimes, imgs, imgs > mxIntensity) ascent[np.isnan(ascent)] = 0 # remove low frequent noise: if min_ascent > 0: i = ascent < min_ascent offset[i] += (0.5 (np.min(expTimes) + np.max(expTimes))) * ascent[i] ascent[i] = 0 return offset, ascent, error
def sortForSameExpTime(expTimes, img_paths): # , excludeSingleImg=True): ''' return image paths sorted for same exposure time ''' d = {} for e, i in zip(expTimes, img_paths): if e not in d: d[e] = [] d[e].append(i) # for key in list(d.keys()): # if len(d[key]) == 1: # print('have only one image of exposure time [%s]' % key) # print('--> exclude that one') # d.pop(key) d = OrderedDict(sorted(d.items())) return list(d.keys()), list(d.values())
def getDarkCurrentAverages(exposuretimes, imgs): ''' return exposure times, image averages for each exposure time ''' x, imgs_p = sortForSameExpTime(exposuretimes, imgs) s0, s1 = imgs[0].shape imgs = np.empty(shape=(len(x), s0, s1), dtype=imgs[0].dtype) for i, ip in zip(imgs, imgs_p): if len(ip) == 1: i[:] = ip[0] else: i[:] = averageSameExpTimes(ip) return x, imgs
def getDarkCurrentFunction(exposuretimes, imgs, kwargs): ''' get dark current function from given images and exposure times ''' exposuretimes, imgs = getDarkCurrentAverages(exposuretimes, imgs) offs, ascent, rmse = getLinearityFunction(exposuretimes, imgs, kwargs) return offs, ascent, rmse
def alignImageAlongLine(img, line, height=15, length=None, zoom=1, fast=False, borderValue=0): ''' return a sub image aligned along given line @param img - numpy.2darray input image to get subimage from @param line - list of 2 points [x0,y0,x1,y1]) @param height - height of output array in y @param length - width of output array @param zoom - zoom factor @param fast - speed up calculation using nearest neighbour interpolation @returns transformed image as numpy.2darray with found line as in the middle ''' height = int(round(height)) if height % 2 == 0: # ->is even number height += 1 # only take uneven numbers to have line in middle if length is None: length = int(round(ln.length(line))) hh = (height - 1) ll = (length - 1) # end points of the line: p0 = np.array(line[0:2], dtype=float) p1 = np.array(line[2:], dtype=float) # p2 is above middle of p0,p1: norm = np.array(ln.normal(line)) if not ln.isHoriz(line): norm = -1 p2 = (p0 + p1) 0.5 + norm * hh * 0.5 middleY = hh / 2 pp0 = [0, middleY] pp1 = [ll, middleY] pp2 = [ll * 0.5, hh] pts1 = np.array([p0, p1, p2], dtype=np.float32) pts2 = np.array([pp0, pp1, pp2], dtype=np.float32) if zoom != 1: length = int(round(length * zoom)) height = int(round(height * zoom)) pts2 *= zoom # TRANSFORM: M = cv2.getAffineTransform(pts1, pts2) dst = cv2.warpAffine( img, M, (length, height), flags=cv2.INTER_NEAREST if fast else cv2.INTER_LINEAR, borderValue=borderValue) return dst
def positionToIntensityUncertainty(image, sx, sy, kernelSize=None): ''' calculates the estimated standard deviation map from the changes of neighbouring pixels from a center pixel within a point spread function defined by a std.dev. in x and y taken from the (sx, sy) maps sx,sy -> either 2d array of same shape as [image] of single values ''' psf_is_const = not isinstance(sx, np.ndarray) if not psf_is_const: assert image.shape == sx.shape == sy.shape, \ "Image and position uncertainty maps need to have same size" if kernelSize is None: kernelSize = _kSizeFromStd(max(sx.max(), sy.max())) else: assert type(sx) in (int, float) and type(sx) in (int, float), \ "Image and position uncertainty values need to be int OR float" if kernelSize is None: kernelSize = _kSizeFromStd(max(sx, sy)) if image.dtype.kind == 'u': image = image.astype(int) # otherwise stack overflow through uint size = kernelSize // 2 if size < 1: size = 1 kernelSize = 1 + 2 * size # array to be filled by individual psf of every pixel: psf = np.zeros((kernelSize, kernelSize)) # intensity uncertainty as stdev: sint = np.zeros(image.shape) if psf_is_const: _calc_constPSF(image, sint, sx, sy, psf, size) else: _calc_variPSF(image, sint, sx, sy, psf, size) return sint
def _coarsenImage(image, f): ''' seems to be a more precise (but slower) way to down-scale an image ''' from skimage.morphology import square from skimage.filters import rank from skimage.transform._warps import rescale selem = square(f) arri = rank.mean(image, selem=selem) return rescale(arri, 1 / f, order=0)
def positionToIntensityUncertaintyForPxGroup(image, std, y0, y1, x0, x1): ''' like positionToIntensityUncertainty but calculated average uncertainty for an area [y0:y1,x0:x1] ''' fy, fx = y1 - y0, x1 - x0 if fy != fx: raise Exception('averaged area need to be square ATM') image = _coarsenImage(image, fx) k = _kSizeFromStd(std) y0 = int(round(y0 / fy)) x0 = int(round(x0 / fx)) arr = image[y0 - k:y0 + k, x0 - k:x0 + k] U = positionToIntensityUncertainty(arr, std / fx, std / fx) return U[k:-k, k:-k]
def nan_maximum_filter(arr, ksize): ''' same as scipy.filters.maximum_filter but working excluding nans ''' out = np.empty_like(arr) _calc(arr, out, ksize//2) return out
def medianThreshold(img, threshold=0.1, size=3, condition='>', copy=True): ''' set every the pixel value of the given [img] to the median filtered one of a given kernel [size] in case the relative [threshold] is exeeded condition = '>' OR '<' ''' from scipy.ndimage import median_filter indices = None if threshold > 0: blur = np.asfarray(median_filter(img, size=size)) with np.errstate(divide='ignore', invalid='ignore', over='ignore'): if condition == '>': indices = abs((img - blur) / blur) > threshold else: indices = abs((img - blur) / blur) < threshold if copy: img = img.copy() img[indices] = blur[indices] return img, indices
def fastFilter(arr, ksize=30, every=None, resize=True, fn='median', interpolation=cv2.INTER_LANCZOS4, smoothksize=0, borderMode=cv2.BORDER_REFLECT): ''' fn['nanmean', 'mean', 'nanmedian', 'median'] a fast 2d filter for large kernel sizes that also works with nans the computation speed is increased because only 'every'nsth position within the median kernel is evaluated ''' if every is None: every = max(ksize//3, 1) else: assert ksize >= 3*every s0,s1 = arr.shape[:2] ss0 = s0//every every = s0//ss0 ss1 = s1//every out = np.full((ss0+1,ss1+1), np.nan) c = {'median':_calcMedian, 'nanmedian':_calcNanMedian, 'nanmean':_calcNanMean, 'mean':_calcMean, }[fn] ss0,ss1 = c(arr, out, ksize, every) out = out[:ss0,:ss1] if smoothksize: out = gaussian_filter(out, smoothksize) if not resize: return out return cv2.resize(out, arr.shape[:2][::-1], interpolation=interpolation)
def elbin(filename): ''' Read EL images (.elbin) created by the RELTRON EL Software http://www.reltron.com/Products/Solar.html ''' # arrs = [] labels = [] # These are all exposure times [s] to be selectable: TIMES = (0.3, 0.4, 0.6, 0.8, 1.2, 1.6, 2.4, 3.2, 4.8, 6.4, 9.6, 12.8, 19.2, 25.6, 38.4, 51.2, 76.8, 102.6, 153.6, 204.6, 307.2, 409.8, 614.4, 819., 1228.8, 1638.6, 3276.6, 5400., 8100., 12168., 18216., 27324., 41004., 61488., 92268.) with open(filename, 'rb') as f: # image shape and number: height, width, frames = np.frombuffer(f.read(4 3), dtype=np.uint32) arrs = np.empty((frames, width, height), dtype=np.uint16) for i in range(frames): # read header between all frames: current, voltage = np.frombuffer(f.read(8 * 2), dtype=np.float64) i_time = np.frombuffer(f.read(4), dtype=np.uint32)[0] time = TIMES[i_time] # read image: arr = np.frombuffer(f.read(width * height * 2), dtype=np.uint16) arrs[i] = arr.reshape(width, height) # last row is all zeros in all imgs # print arr[:,:-1] # arrs.append(arr) labels.append({'exposure time[s]': time, 'current[A]': current, 'voltage[V]': voltage}) return arrs, labels
def gaussian2d(xy, sx, sy, mx=0, my=0, rho=0, amp=1, offs=0): ''' see http://en.wikipedia.org/wiki/Multivariate_normal_distribution # probability density function of a vector [x,y] sx,sy -> sigma (standard deviation) mx,my: mue (mean position) rho: correlation between x and y ''' x,y = xy return offs+amp( 1/(2np.pisxsy(1-(rho2))0.5) np.exp( (-1/(2(1-rho2))) ( ( (x-mx)2/sx2 ) + ( (y-my)2/sy2 ) - ( ( 2rho(x-mx)(y-my)) / (sxsy) ) ) ) )
def fitImg(self, img_rgb): ''' fit perspective and size of the input image to the base image ''' H = self.pattern.findHomography(img_rgb)[0] H_inv = self.pattern.invertHomography(H) s = self.img_orig.shape warped = cv2.warpPerspective(img_rgb, H_inv, (s[1], s[0])) return warped
def scaleSignalCut(img, ratio, nbins=100): ''' scaling img cutting x percent of top and bottom part of histogram ''' start, stop = scaleSignalCutParams(img, ratio, nbins) img = img - start img /= (stop - start) return img
def scaleSignal(img, fitParams=None, backgroundToZero=False, reference=None): ''' scale the image between... backgroundToZero=True -> 0 (average background) and 1 (maximum signal) backgroundToZero=False -> signal+-3std reference -> reference image -- scale image to fit this one returns: scaled image ''' img = imread(img) if reference is not None: # def fn(ii, m,n): # return iim+n # curve_fit(fn, img[::10,::10], ref[::10,::10]) low, high = signalRange(img, fitParams) low2, high2 = signalRange(reference) img = np.asfarray(img) ampl = (high2 - low2) / (high - low) img -= low img = ampl img += low2 return img else: offs, div = scaleParams(img, fitParams, backgroundToZero) img = np.asfarray(img) - offs img /= div print('offset: %s, divident: %s' % (offs, div)) return img
def getBackgroundRange(fitParams): ''' return minimum, average, maximum of the background peak ''' smn, _, _ = getSignalParameters(fitParams) bg = fitParams[0] _, avg, std = bg bgmn = max(0, avg - 3 * std) if avg + 4 * std < smn: bgmx = avg + 4 * std if avg + 3 * std < smn: bgmx = avg + 3 * std if avg + 2 * std < smn: bgmx = avg + 2 * std else: bgmx = avg + std return bgmn, avg, bgmx
def hasBackground(fitParams): ''' compare the height of putative bg and signal peak if ratio if too height assume there is no background ''' signal = getSignalPeak(fitParams) bg = getBackgroundPeak(fitParams) if signal == bg: return False r = signal[0] / bg[0] if r < 1: r = 1 / r return r < 100
def signalMinimum2(img, bins=None): ''' minimum position between signal and background peak ''' f = FitHistogramPeaks(img, bins=bins) i = signalPeakIndex(f.fitParams) spos = f.fitParams[i][1] # spos = getSignalPeak(f.fitParams)[1] # bpos = getBackgroundPeak(f.fitParams)[1] bpos = f.fitParams[i - 1][1] ind = np.logical_and(f.xvals > bpos, f.xvals < spos) try: i = np.argmin(f.yvals[ind]) return f.xvals[ind][i] except ValueError as e: if bins is None: return signalMinimum2(img, bins=400) else: raise e
def signalMinimum(img, fitParams=None, n_std=3): ''' intersection between signal and background peak ''' if fitParams is None: fitParams = FitHistogramPeaks(img).fitParams assert len(fitParams) > 1, 'need 2 peaks so get minimum signal' i = signalPeakIndex(fitParams) signal = fitParams[i] bg = getBackgroundPeak(fitParams) smn = signal[1] - n_std * signal[2] bmx = bg[1] + n_std * bg[2] if smn > bmx: return smn # peaks are overlapping # define signal min. as intersection between both Gaussians def solve(p1, p2): s1, m1, std1 = p1 s2, m2, std2 = p2 a = (1 / (2 * std1*2)) - (1 / (2 std22)) b = (m2 / (std22)) - (m1 / (std12)) c = (m12 / (2 * std12)) - (m22 / (2 * std2*2)) - \ np.log(((std2 s1) / (std1 * s2))) return np.roots([a, b, c]) i = solve(bg, signal) try: return i[np.logical_and(i > bg[1], i < signal[1])][0] except IndexError: # this error shouldn't occur... well return max(smn, bmx)
def getSignalParameters(fitParams, n_std=3): ''' return minimum, average, maximum of the signal peak ''' signal = getSignalPeak(fitParams) mx = signal[1] + n_std * signal[2] mn = signal[1] - n_std * signal[2] if mn < fitParams[0][1]: mn = fitParams[0][1] # set to bg return mn, signal[1], mx
def equalizeImage(img, save_path=None, name_additive='_eqHist'): ''' Equalize the histogram (contrast) of an image works with RGB/multi-channel images and flat-arrays @param img - image_path or np.array @param save_path if given output images will be saved there @param name_additive if given this additive will be appended to output images @return output images if input images are numpy.arrays and no save_path is given @return None elsewise ''' if isinstance(img, string_types): img = PathStr(img) if not img.exists(): raise Exception("image path doesn't exist") img_name = img.basename().replace('.', '%s.' % name_additive) if save_path is None: save_path = img.dirname() img = cv2.imread(img) if img.dtype != np.dtype('uint8'): # openCV cannot work with float arrays or uint > 8bit eqFn = _equalizeHistogram else: eqFn = cv2.equalizeHist if len(img.shape) == 3: # multi channel img like rgb for i in range(img.shape[2]): img[:, :, i] = eqFn(img[:, :, i]) else: # grey scale image img = eqFn(img) if save_path: img_name = PathStr(save_path).join(img_name) cv2.imwrite(img_name, img) return img
def _equalizeHistogram(img): ''' histogram equalisation not bounded to int() or an image depth of 8 bit works also with negative numbers ''' # to float if int: intType = None if 'f' not in img.dtype.str: TO_FLOAT_TYPES = {np.dtype('uint8'): np.float16, np.dtype('uint16'): np.float32, np.dtype('uint32'): np.float64, np.dtype('uint64'): np.float64} intType = img.dtype img = img.astype(TO_FLOAT_TYPES[intType], copy=False) # get image deph DEPTH_TO_NBINS = {np.dtype('float16'): 256, # uint8 np.dtype('float32'): 32768, # uint16 np.dtype('float64'): 2147483648} # uint32 nBins = DEPTH_TO_NBINS[img.dtype] # scale to -1 to 1 due to skikit-image restrictions mn, mx = np.amin(img), np.amax(img) if abs(mn) > abs(mx): mx = mn img /= mx img = exposure.equalize_hist(img, nbins=nBins) img *= mx if intType: img = img.astype(intType) return img
def localizedMaximum(img, thresh=0, min_increase=0, max_length=0, dtype=bool): ''' Returns the local maximum of a given 2d array thresh -> if given, ignore all values below that value max_length -> limit length between value has to vary > min_increase >>> a = np.array([[0,1,2,3,2,1,0], \ [0,1,2,2,3,1,0], \ [0,1,1,2,2,3,0], \ [0,1,1,2,1,1,0], \ [0,0,0,1,1,0,0]]) >>> print localizedMaximum(a, dtype=int) [[0 1 1 1 0 1 0] [0 0 0 0 1 0 0] [0 0 0 1 0 1 0] [0 0 1 1 0 1 0] [0 0 0 1 0 0 0]] ''' # because numba cannot create arrays: out = np.zeros(shape=img.shape, dtype=dtype) # first iterate all rows: _calc(img, out, thresh, min_increase, max_length) # that all columns: _calc(img.T, out.T, thresh, min_increase, max_length) return out
def setReference(self, ref): ''' ref ... either quad, grid, homography or reference image quad --> list of four image points(x,y) marking the edges of the quad to correct homography --> h. matrix to correct perspective distortion referenceImage --> image of same object without perspective distortion ''' # self.maps = {} self.quad = None # self.refQuad = None self._camera_position = None self._homography = None self._homography_is_fixed = True # self.tvec, self.rvec = None, None self._pose = None # evaluate input: if isinstance(ref, np.ndarray) and ref.shape == (3, 3): # REF IS HOMOGRAPHY self._homography = ref # REF IS QUAD elif len(ref) == 4: self.quad = sortCorners(ref) # TODO: cleanup # only need to call once - here o = self.obj_points # no property any more # REF IS IMAGE else: self.ref = imread(ref) # self._refshape = ref.shape[:2] self.pattern = PatternRecognition(self.ref) self._homography_is_fixed = False
def distort(self, img, rotX=0, rotY=0, quad=None): ''' Apply perspective distortion ion self.img angles are in DEG and need to be positive to fit into image ''' self.img = imread(img) # fit old image to self.quad: corr = self.correct(self.img) s = self.img.shape if quad is None: wquad = (self.quad - self.quad.mean(axis=0)).astype(float) win_width = s[1] win_height = s[0] # project quad: for n, q in enumerate(wquad): p = Point3D(q[0], q[1], 0).rotateX(-rotX).rotateY(-rotY) p = p.project(win_width, win_height, s[1], s[1]) wquad[n] = (p.x, p.y) wquad = sortCorners(wquad) # scale result so that longest side of quad and wquad are equal w = wquad[:, 0].max() - wquad[:, 0].min() h = wquad[:, 1].max() - wquad[:, 1].min() scale = min(s[1] / w, s[0] / h) # scale: wquad = (wquad * scale).astype(int) else: wquad = sortCorners(quad) wquad -= wquad.min(axis=0) lx = corr.shape[1] ly = corr.shape[0] objP = np.array([ [0, 0], [lx, 0], [lx, ly], [0, ly], ], dtype=np.float32) homography = cv2.getPerspectiveTransform( wquad.astype(np.float32), objP) # distort corr: w = wquad[:, 0].max() - wquad[:, 0].min() h = wquad[:, 1].max() - wquad[:, 1].min() #(int(w),int(h)) dist = cv2.warpPerspective(corr, homography, (int(w), int(h)), flags=cv2.INTER_CUBIC \| cv2.WARP_INVERSE_MAP) # move middle of dist to middle of the old quad: bg = np.zeros(shape=s) rmn = (bg.shape[0] / 2, bg.shape[1] / 2) ss = dist.shape mn = (ss[0] / 2, ss[1] / 2) # wquad.mean(axis=0) ref = (int(rmn[0] - mn[0]), int(rmn[1] - mn[1])) bg[ref[0]:ss[0] + ref[0], ref[1]:ss[1] + ref[1]] = dist # finally move quad into right position: self.quad = wquad self.quad += (ref[1], ref[0]) self.img = bg self._homography = None self._poseFromQuad() if self.opts['do_correctIntensity']: tf = self.tiltFactor() if self.img.ndim == 3: for col in range(self.img.shape[2]): self.img[..., col] = tf else: # tf = np.tile(tf, (1,1,self.img.shape[2])) self.img = self.img tf return self.img
def correctGrid(self, img, grid): ''' grid -> array of polylines=((p0x,p0y),(p1x,p1y),,,) ''' self.img = imread(img) h = self.homography # TODO: cleanup only needed to get newBorder attr. if self.opts['do_correctIntensity']: self.img = self.img / self._getTiltFactor(self.img.shape) s0, s1 = grid.shape[:2] n0, n1 = s0 - 1, s1 - 1 snew = self._newBorders b = self.opts['border'] sx, sy = (snew[0] - 2 * b) // n0, (snew[1] - 2 * b) // n1 out = np.empty(snew[::-1], dtype=self.img.dtype) def warp(ix, iy, objP, outcut): shape = outcut.shape[::-1] quad = grid[ix:ix + 2, iy:iy + 2].reshape(4, 2)[np.array([0, 2, 3, 1])] hcell = cv2.getPerspectiveTransform( quad.astype(np.float32), objP) cv2.warpPerspective(self.img, hcell, shape, outcut, flags=cv2.INTER_LANCZOS4, *self.opts['cv2_opts']) return quad objP = np.array([[0, 0], [sx, 0], [sx, sy], [0, sy]], dtype=np.float32) # INNER CELLS for ix in range(1, n0 - 1): for iy in range(1, n1 - 1): sub = out[iy sy + b: (iy + 1) * sy + b, ix * sx + b: (ix + 1) * sx + b] # warp(ix, iy, objP, sub) shape = sub.shape[::-1] quad = grid[ix:ix + 2, iy:iy + 2].reshape(4, 2)[np.array([0, 2, 3, 1])] # print(quad, objP) hcell = cv2.getPerspectiveTransform( quad.astype(np.float32), objP) cv2.warpPerspective(self.img, hcell, shape, sub, flags=cv2.INTER_LANCZOS4, *self.opts['cv2_opts']) # return out # TOP CELLS objP[:, 1] += b for ix in range(1, n0 - 1): warp(ix, 0, objP, out[: sy + b, ix sx + b: (ix + 1) * sx + b]) # BOTTOM CELLS objP[:, 1] -= b for ix in range(1, n0 - 1): iy = (n1 - 1) y = iy * sy + b x = ix * sx + b warp(ix, iy, objP, out[y: y + sy + b, x: x + sx]) # LEFT CELLS objP[:, 0] += b for iy in range(1, n1 - 1): y = iy * sy + b warp(0, iy, objP, out[y: y + sy, : sx + b]) # RIGHT CELLS objP[:, 0] -= b ix = (n0 - 1) x = ix * sx + b for iy in range(1, n1 - 1): y = iy * sy + b warp(ix, iy, objP, out[y: y + sy, x: x + sx + b]) # BOTTOM RIGHT CORNER warp(n0 - 1, n1 - 1, objP, out[-sy - b - 1:, x: x + sx + b]) # #TOP LEFT CORNER objP += (b, b) warp(0, 0, objP, out[0: sy + b, 0: sx + b]) # TOP RIGHT CORNER objP[:, 0] -= b # x = (n0-1)*sx+b warp(n0 - 1, 0, objP, out[: sy + b, x: x + sx + b]) # #BOTTOM LEFT CORNER objP += (b, -b) warp(0, n1 - 1, objP, out[-sy - b - 1:, : sx + b]) return out
def correct(self, img): ''' ...from perspective distortion: --> perspective transformation --> apply tilt factor (view factor) correction ''' print("CORRECT PERSPECTIVE ...") self.img = imread(img) if not self._homography_is_fixed: self._homography = None h = self.homography if self.opts['do_correctIntensity']: tf = self.tiltFactor() self.img = np.asfarray(self.img) if self.img.ndim == 3: for col in range(self.img.shape[2]): self.img[..., col] /= tf else: self.img = self.img / tf warped = cv2.warpPerspective(self.img, h, self._newBorders[::-1], flags=cv2.INTER_LANCZOS4, **self.opts['cv2_opts']) return warped
def camera_position(self, pose=None): ''' returns camera position in world coordinates using self.rvec and self.tvec from http://stackoverflow.com/questions/14515200/python-opencv-solvepnp-yields-wrong-translation-vector ''' if pose is None: pose = self.pose() t, r = pose return -np.matrix(cv2.Rodrigues(r)[0]).T * np.matrix(t)
def viewAngle(self, *kwargs): ''' calculate view factor between one small and one finite surface vf =1/pi integral(cos(beta1)cos(beta2)/s2) dA according to VDI heatatlas 2010 p961 ''' v0 = self.cam2PlaneVectorField(*kwargs) # obj cannot be behind camera v0[2][v0[2] < 0] = np.nan _t, r = self.pose() n = self.planeSfN(r) # because of different x,y orientation: n[2] = -1 # beta2 = vectorAngle(v0, vectorToField(n) ) beta2 = vectorAngle(v0, n) return beta2
def foreground(self, quad=None): '''return foreground (quad) mask''' fg = np.zeros(shape=self._newBorders[::-1], dtype=np.uint8) if quad is None: quad = self.quad else: quad = quad.astype(np.int32) cv2.fillConvexPoly(fg, quad, 1) return fg.astype(bool)
def tiltFactor(self, midpointdepth=None, printAvAngle=False): ''' get tilt factor from inverse distance law https://en.wikipedia.org/wiki/Inverse-square_law ''' # TODO: can also be only def. with FOV, rot, tilt beta2 = self.viewAngle(midpointdepth=midpointdepth) try: angles, vals = getattr( emissivity_vs_angle, self.opts['material'])() except AttributeError: raise AttributeError("material[%s] is not in list of know materials: %s" % ( self.opts['material'], [o[0] for o in getmembers(emissivity_vs_angle) if isfunction(o[1])])) if printAvAngle: avg_angle = beta2[self.foreground()].mean() print('angle: %s DEG' % np.degrees(avg_angle)) # use averaged angle instead of beta2 to not overemphasize correction normEmissivity = np.clip( InterpolatedUnivariateSpline( np.radians(angles), vals)(beta2), 0, 1) return normEmissivity
def standardUncertainties(self, focal_Length_mm, f_number, midpointdepth=1000, focusAtYX=None, # sigma_best_focus=0, # quad_pos_err=0, shape=None, uncertainties=(0, 0)): ''' focusAtXY - image position with is in focus if not set it is assumed that the image middle is in focus sigma_best_focus - standard deviation of the PSF within the best focus (default blur) uncertainties - contibutors for standard uncertainty these need to be perspective transformed to fit the new image shape ''' # TODO: consider quad_pos_error # (also influences intensity corr map) if shape is None: s = self.img.shape else: s = shape # 1. DEFOCUS DUE TO DEPTH OF FIELD ################################## depthMap = self.depthMap(midpointdepth) if focusAtYX is None: # assume image middle is in-focus: focusAtYX = s[0] // 2, s[1] // 2 infocusDepth = depthMap[focusAtYX] depthOfField_blur = defocusThroughDepth( depthMap, infocusDepth, focal_Length_mm, f_number, k=2.335) # 2. INCREAASED PIXEL SIZE DUE TO INTERPOLATION BETWEEN # PIXELS MOVED APARD ###################################################### # index maps: py, px = np.mgrid[0:s[0], 0:s[1]] # warped index maps: wx = cv2.warpPerspective(np.asfarray(px), self.homography, self._newBorders, borderValue=np.nan, flags=cv2.INTER_LANCZOS4) wy = cv2.warpPerspective(np.asfarray(py), self.homography, self._newBorders, borderValue=np.nan, flags=cv2.INTER_LANCZOS4) pxSizeFactorX = 1 / np.abs(np.gradient(wx)[1]) pxSizeFactorY = 1 / np.abs(np.gradient(wy)[0]) # WARP ALL FIELD TO NEW PERSPECTIVE AND MULTIPLY WITH PXSIZE FACTOR: depthOfField_blur = cv2.warpPerspective( depthOfField_blur, self.homography, self._newBorders, borderValue=np.nan, ) # perspective transform given uncertainties: warpedU = [] for u in uncertainties: # warpedU.append([]) # for i in u: # print i, type(i), isinstance(i, np.ndarray) if isinstance(u, np.ndarray) and u.size > 1: u = cv2.warpPerspective(u, self.homography, self._newBorders, borderValue=np.nan, flags=cv2.INTER_LANCZOS4) # f else: # multiply with area ratio: after/before perspective warp u = self.areaRatio warpedU.append(u) # given uncertainties after warp: ux, uy = warpedU ux = pxSizeFactorX * (ux2 + depthOfField_blur2)*0.5 uy = pxSizeFactorY (uy2 + depthOfField_blur2)**0.5 # TODO: remove depthOfField_blur,fx,fy from return return ux, uy, depthOfField_blur, pxSizeFactorX, pxSizeFactorY
def _poseFromQuad(self, quad=None): ''' estimate the pose of the object plane using quad setting: self.rvec -> rotation vector self.tvec -> translation vector ''' if quad is None: quad = self.quad if quad.ndim == 3: quad = quad[0] # http://answers.opencv.org/question/1073/what-format-does-cv2solvepnp-use-for-points-in/ # Find the rotation and translation vectors. img_pn = np.ascontiguousarray(quad[:, :2], dtype=np.float32).reshape((4, 1, 2)) obj_pn = self.obj_points - self.obj_points.mean(axis=0) retval, rvec, tvec = cv2.solvePnP( obj_pn, img_pn, self.opts['cameraMatrix'], self.opts['distCoeffs'], flags=cv2.SOLVEPNP_P3P # because exactly four points are given ) if not retval: print("Couln't estimate pose") return tvec, rvec
def drawQuad(self, img=None, quad=None, thickness=30): ''' Draw the quad into given img ''' if img is None: img = self.img if quad is None: quad = self.quad q = np.int32(quad) c = int(img.max()) cv2.line(img, tuple(q[0]), tuple(q[1]), c, thickness) cv2.line(img, tuple(q[1]), tuple(q[2]), c, thickness) cv2.line(img, tuple(q[2]), tuple(q[3]), c, thickness) cv2.line(img, tuple(q[3]), tuple(q[0]), c, thickness) return img
def draw3dCoordAxis(self, img=None, thickness=8): ''' draw the 3d coordinate axes into given image if image == False: create an empty image ''' if img is None: img = self.img elif img is False: img = np.zeros(shape=self.img.shape, dtype=self.img.dtype) else: img = imread(img) # project 3D points to image plane: # self.opts['obj_width_mm'], self.opts['obj_height_mm'] w, h = self.opts['new_size'] axis = np.float32([[0.5 * w, 0.5 * h, 0], [w, 0.5 * h, 0], [0.5 * w, h, 0], [0.5 * w, 0.5 * h, -0.5 * w]]) t, r = self.pose() imgpts = cv2.projectPoints(axis, r, t, self.opts['cameraMatrix'], self.opts['distCoeffs'])[0] mx = int(img.max()) origin = tuple(imgpts[0].ravel()) cv2.line(img, origin, tuple(imgpts[1].ravel()), (0, 0, mx), thickness) cv2.line(img, origin, tuple(imgpts[2].ravel()), (0, mx, 0), thickness) cv2.line( img, origin, tuple(imgpts[3].ravel()), (mx, 0, 0), thickness * 2) return img
def _calcQuadSize(corners, aspectRatio): ''' return the size of a rectangle in perspective distortion in [px] DEBUG: PUT THAT BACK IN??:: if aspectRatio is not given is will be determined ''' if aspectRatio > 1: # x is bigger -> reduce y x_length = PerspectiveCorrection._quadXLength(corners) y = x_length / aspectRatio return x_length, y else: # y is bigger -> reduce x y_length = PerspectiveCorrection._quadYLength(corners) x = y_length * aspectRatio return x, y_length
def linearToPolar(img, center=None, final_radius=None, initial_radius=None, phase_width=None, interpolation=cv2.INTER_AREA, maps=None, borderValue=0, borderMode=cv2.BORDER_REFLECT, opts): ''' map a 2d (x,y) Cartesian array to a polar (r, phi) array using opencv.remap ''' if maps is None: mapY, mapX = linearToPolarMaps(img.shape[:2], center, final_radius, initial_radius, phase_width) else: mapY, mapX = maps o = {'interpolation': interpolation, 'borderValue': borderValue, 'borderMode': borderMode} o.update(opts) return cv2.remap(img, mapY, mapX, o)
def polarToLinear(img, shape=None, center=None, maps=None, interpolation=cv2.INTER_AREA, borderValue=0, borderMode=cv2.BORDER_REFLECT, opts): ''' map a 2d polar (r, phi) polar array to a Cartesian (x,y) array using opencv.remap ''' if maps is None: mapY, mapX = polarToLinearMaps(img.shape[:2], shape, center) else: mapY, mapX = maps o = {'interpolation': interpolation, 'borderValue': borderValue, 'borderMode': borderMode} o.update(opts) return cv2.remap(img, mapY, mapX, o)
def modifiedLaplacian(img): ''''LAPM' algorithm (Nayar89)''' M = np.array([-1, 2, -1]) G = cv2.getGaussianKernel(ksize=3, sigma=-1) Lx = cv2.sepFilter2D(src=img, ddepth=cv2.CV_64F, kernelX=M, kernelY=G) Ly = cv2.sepFilter2D(src=img, ddepth=cv2.CV_64F, kernelX=G, kernelY=M) FM = np.abs(Lx) + np.abs(Ly) return cv2.mean(FM)[0]
def varianceOfLaplacian(img): ''''LAPV' algorithm (Pech2000)''' lap = cv2.Laplacian(img, ddepth=-1)#cv2.cv.CV_64F) stdev = cv2.meanStdDev(lap)[1] s = stdev[0]**2 return s[0]
def tenengrad(img, ksize=3): ''''TENG' algorithm (Krotkov86)''' Gx = cv2.Sobel(img, ddepth=cv2.CV_64F, dx=1, dy=0, ksize=ksize) Gy = cv2.Sobel(img, ddepth=cv2.CV_64F, dx=0, dy=1, ksize=ksize) FM = GxGx + GyGy mn = cv2.mean(FM)[0] if np.isnan(mn): return np.nanmean(FM) return mn
def normalizedGraylevelVariance(img): ''''GLVN' algorithm (Santos97)''' mean, stdev = cv2.meanStdDev(img) s = stdev[0]**2 / mean[0] return s[0]
def linePlot(img, x0, y0, x1, y1, resolution=None, order=3): ''' returns [img] intensity values along line defined by [x0, y0, x1, y1] resolution ... number or data points to evaluate order ... interpolation precision ''' if resolution is None: resolution = int( ((x1-x0)2 + (y1-y0)2 )**0.5 ) if order == 0: x = np.linspace(x0, x1, resolution, dtype=int) y = np.linspace(y0, y1, resolution, dtype=int) return img[y, x] x = np.linspace(x0, x1, resolution) y = np.linspace(y0, y1, resolution) return map_coordinates(img, np.vstack((y,x)), order=order)
def flatFieldFromFunction(self): ''' calculate flatField from fitting vignetting function to averaged fit-image returns flatField, average background level, fitted image, valid indices mask ''' fitimg, mask = self._prepare() mask = ~mask s0, s1 = fitimg.shape #f-value, alpha, fx, cx, cy guess = (s1 * 0.7, 0, 1, s0 / 2, s1 / 2) # set assume normal plane - no tilt and rotation: fn = lambda xy, f, alpha, fx, cx, cy: vignetting((xy[0] * fx, xy[1]), f, alpha, cx=cx, cy=cy) # mask = fitimg>0.5 flatfield = fit2dArrayToFn(fitimg, fn, mask=mask, guess=guess, output_shape=self._orig_shape)[0] return flatfield, self.bglevel / self._n, fitimg, mask
def flatFieldFromFit(self): ''' calculate flatField from 2d-polynomal fit filling all high gradient areas within averaged fit-image returns flatField, average background level, fitted image, valid indices mask ''' fitimg, mask = self._prepare() out = fitimg.copy() lastm = 0 for _ in range(10): out = polyfit2dGrid(out, mask, 2) mask = highGrad(out) m = mask.sum() if m == lastm: break lastm = m out = np.clip(out, 0.1, 1) out = resize(out, self._orig_shape, mode='reflect') return out, self.bglevel / self._n, fitimg, mask
def parse_vhdl_file(fname): '''Parse a named VHDL file Args: fname(str): Name of file to parse Returns: Parsed objects. ''' with open(fname, 'rt') as fh: text = fh.read() return parse_vhdl(text)
def parse_vhdl(text): '''Parse a text buffer of VHDL code Args: text(str): Source code to parse Returns: Parsed objects. ''' lex = VhdlLexer name = None kind = None saved_type = None end_param_group = False cur_package = None metacomments = [] parameters = [] param_items = [] generics = [] ports = [] sections = [] port_param_index = 0 last_item = None array_range_start_pos = 0 objects = [] for pos, action, groups in lex.run(text): if action == 'metacomment': realigned = re.sub(r'^#+', lambda m: ' ' * len(m.group(0)), groups[0]) if last_item is None: metacomments.append(realigned) else: last_item.desc = realigned if action == 'section_meta': sections.append((port_param_index, groups[0])) elif action == 'function': kind = 'function' name = groups[0] param_items = [] parameters = [] elif action == 'procedure': kind = 'procedure' name = groups[0] param_items = [] parameters = [] elif action == 'param': if end_param_group: # Complete previous parameters for i in param_items: parameters.append(i) param_items = [] end_param_group = False param_items.append(VhdlParameter(groups[1])) elif action == 'param_type': mode, ptype = groups if mode is not None: mode = mode.strip() for i in param_items: # Set mode and type for all pending parameters i.mode = mode i.data_type = ptype end_param_group = True elif action == 'param_default': for i in param_items: i.default_value = groups[0] elif action == 'end_subprogram': # Complete last parameters for i in param_items: parameters.append(i) if kind == 'function': vobj = VhdlFunction(name, cur_package, parameters, groups[0], metacomments) else: vobj = VhdlProcedure(name, cur_package, parameters, metacomments) objects.append(vobj) metacomments = [] parameters = [] param_items = [] kind = None name = None elif action == 'component': kind = 'component' name = groups[0] generics = [] ports = [] param_items = [] sections = [] port_param_index = 0 elif action == 'generic_param': param_items.append(groups[0]) elif action == 'generic_param_type': ptype = groups[0] for i in param_items: generics.append(VhdlParameter(i, 'in', ptype)) param_items = [] last_item = generics[-1] elif action == 'port_param': param_items.append(groups[0]) port_param_index += 1 elif action == 'port_param_type': mode, ptype = groups for i in param_items: ports.append(VhdlParameter(i, mode, ptype)) param_items = [] last_item = ports[-1] elif action == 'port_array_param_type': mode, ptype = groups array_range_start_pos = pos[1] elif action == 'array_range_end': arange = text[array_range_start_pos:pos[0]+1] for i in param_items: ports.append(VhdlParameter(i, mode, ptype + arange)) param_items = [] last_item = ports[-1] elif action == 'end_component': vobj = VhdlComponent(name, cur_package, ports, generics, dict(sections), metacomments) objects.append(vobj) last_item = None metacomments = [] elif action == 'package': objects.append(VhdlPackage(groups[0])) cur_package = groups[0] kind = None name = None elif action == 'type': saved_type = groups[0] elif action in ('array_type', 'file_type', 'access_type', 'record_type', 'range_type', 'enum_type', 'incomplete_type'): vobj = VhdlType(saved_type, cur_package, action, metacomments) objects.append(vobj) kind = None name = None metacomments = [] elif action == 'subtype': vobj = VhdlSubtype(groups[0], cur_package, groups[1], metacomments) objects.append(vobj) kind = None name = None metacomments = [] elif action == 'constant': vobj = VhdlConstant(groups[0], cur_package, groups[1], metacomments) objects.append(vobj) kind = None name = None metacomments = [] return objects
def subprogram_prototype(vo): '''Generate a canonical prototype string Args: vo (VhdlFunction, VhdlProcedure): Subprogram object Returns: Prototype string. ''' plist = '; '.join(str(p) for p in vo.parameters) if isinstance(vo, VhdlFunction): if len(vo.parameters) > 0: proto = 'function {}({}) return {};'.format(vo.name, plist, vo.return_type) else: proto = 'function {} return {};'.format(vo.name, vo.return_type) else: # procedure proto = 'procedure {}({});'.format(vo.name, plist) return proto
def subprogram_signature(vo, fullname=None): '''Generate a signature string Args: vo (VhdlFunction, VhdlProcedure): Subprogram object Returns: Signature string. ''' if fullname is None: fullname = vo.name if isinstance(vo, VhdlFunction): plist = ','.join(p.data_type for p in vo.parameters) sig = '{}[{} return {}]'.format(fullname, plist, vo.return_type) else: # procedure plist = ','.join(p.data_type for p in vo.parameters) sig = '{}[{}]'.format(fullname, plist) return sig
def extract_objects_from_source(self, text, type_filter=None): '''Extract object declarations from a text buffer Args: text (str): Source code to parse type_filter (class, optional): Object class to filter results Returns: List of parsed objects. ''' objects = parse_vhdl(text) self._register_array_types(objects) if type_filter: objects = [o for o in objects if isinstance(o, type_filter)] return objects
def is_array(self, data_type): '''Check if a type is a known array type Args: data_type (str): Name of type to check Returns: True if ``data_type`` is a known array type. ''' # Split off any brackets data_type = data_type.split('[')[0].strip() return data_type.lower() in self.array_types
def load_array_types(self, fname): '''Load file of previously extracted data types Args: fname (str): Name of file to load array database from ''' type_defs = '' with open(fname, 'rt') as fh: type_defs = fh.read() try: type_defs = ast.literal_eval(type_defs) except SyntaxError: type_defs = {} self._add_array_types(type_defs)
def save_array_types(self, fname): '''Save array type registry to a file Args: fname (str): Name of file to save array database to ''' type_defs = {'arrays': sorted(list(self.array_types))} with open(fname, 'wt') as fh: pprint(type_defs, stream=fh)
def _register_array_types(self, objects): '''Add array type definitions to internal registry Args: objects (list of VhdlType or VhdlSubtype): Array types to track ''' # Add all array types directly types = [o for o in objects if isinstance(o, VhdlType) and o.type_of == 'array_type'] for t in types: self.array_types.add(t.name) subtypes = {o.name:o.base_type for o in objects if isinstance(o, VhdlSubtype)} # Find all subtypes of an array type for k,v in subtypes.iteritems(): while v in subtypes: # Follow subtypes of subtypes v = subtypes[v] if v in self.array_types: self.array_types.add(k)
def register_array_types_from_sources(self, source_files): '''Add array type definitions from a file list to internal registry Args: source_files (list of str): Files to parse for array definitions ''' for fname in source_files: if is_vhdl(fname): self._register_array_types(self.extract_objects(fname))
def run(self, text): '''Run lexer rules against a source text Args: text (str): Text to apply lexer to Yields: A sequence of lexer matches. ''' stack = ['root'] pos = 0 patterns = self.tokens[stack[-1]] while True: for pat, action, new_state in patterns: m = pat.match(text, pos) if m: if action: #print('## MATCH: {} -> {}'.format(m.group(), action)) yield (pos, m.end()-1), action, m.groups() pos = m.end() if new_state: if isinstance(new_state, int): # Pop states del stack[new_state:] else: stack.append(new_state) #print('## CHANGE STATE:', pos, new_state, stack) patterns = self.tokens[stack[-1]] break else: try: if text[pos] == '\n': pos += 1 continue pos += 1 except IndexError: break
def get_package_version(verfile): '''Scan the script for the version string''' version = None with open(verfile) as fh: try: version = [line.split('=')[1].strip().strip("'") for line in fh if \ line.startswith('__version__')][0] except IndexError: pass return version
def parse_verilog_file(fname): '''Parse a named Verilog file Args: fname (str): File to parse. Returns: List of parsed objects. ''' with open(fname, 'rt') as fh: text = fh.read() return parse_verilog(text)
def parse_verilog(text): '''Parse a text buffer of Verilog code Args: text (str): Source code to parse Returns: List of parsed objects. ''' lex = VerilogLexer name = None kind = None saved_type = None mode = 'input' ptype = 'wire' metacomments = [] parameters = [] param_items = [] generics = [] ports = collections.OrderedDict() sections = [] port_param_index = 0 last_item = None array_range_start_pos = 0 objects = [] for pos, action, groups in lex.run(text): if action == 'metacomment': if last_item is None: metacomments.append(groups[0]) else: last_item.desc = groups[0] if action == 'section_meta': sections.append((port_param_index, groups[0])) elif action == 'module': kind = 'module' name = groups[0] generics = [] ports = collections.OrderedDict() param_items = [] sections = [] port_param_index = 0 elif action == 'parameter_start': net_type, vec_range = groups new_ptype = '' if net_type is not None: new_ptype += net_type if vec_range is not None: new_ptype += ' ' + vec_range ptype = new_ptype elif action == 'param_item': generics.append(VerilogParameter(groups[0], 'in', ptype)) elif action == 'module_port_start': new_mode, net_type, signed, vec_range = groups new_ptype = '' if net_type is not None: new_ptype += net_type if signed is not None: new_ptype += ' ' + signed if vec_range is not None: new_ptype += ' ' + vec_range # Complete pending items for i in param_items: ports[i] = VerilogParameter(i, mode, ptype) param_items = [] if len(ports) > 0: last_item = next(reversed(ports)) # Start with new mode mode = new_mode ptype = new_ptype elif action == 'port_param': ident = groups[0] param_items.append(ident) port_param_index += 1 elif action == 'end_module': # Finish any pending ports for i in param_items: ports[i] = VerilogParameter(i, mode, ptype) vobj = VerilogModule(name, ports.values(), generics, dict(sections), metacomments) objects.append(vobj) last_item = None metacomments = [] return objects

def patStarLines(s0): '''make line pattern''' arr = np.zeros((s0,s0), dtype=np.uint8) col = 255 t = int(s0/100.) for pos in np.linspace(0,np.pi/2,15): p0 = int(round(np.sin(pos)*s0*2)) p1 = int(round(np.cos(pos)*s0*2)) cv2.line(arr,(0,0),(p0,p1), color=col, thickness=t, lineType=cv2.LINE_AA ) return arr.astype(float)

def patSiemensStar(s0, n=72, vhigh=255, vlow=0, antiasing=False): '''make line pattern''' arr = np.full((s0,s0),vlow, dtype=np.uint8) c = int(round(s0/2.)) s = 2*np.pi/(2*n) step = 0 for i in range(2*n): p0 = round(c+np.sin(step)*2*s0) p1 = round(c+np.cos(step)*2*s0) step += s p2 = round(c+np.sin(step)*2*s0) p3 = round(c+np.cos(step)*2*s0) pts = np.array(((c,c), (p0,p1), (p2,p3) ), dtype=int) cv2.fillConvexPoly(arr, pts, color=vhigh if i%2 else vlow, lineType=cv2.LINE_AA if antiasing else 0) arr[c,c]=0 return arr.astype(float)

def patText(s0): '''make text pattern''' arr = np.zeros((s0,s0), dtype=np.uint8) s = int(round(s0/100.)) p1 = 0 pp1 = int(round(s0/10.)) for pos0 in np.linspace(0,s0,10): cv2.putText(arr, 'helloworld', (p1,int(round(pos0))), cv2.FONT_HERSHEY_COMPLEX_SMALL, fontScale=s, color=255, thickness=s, lineType=cv2.LINE_AA ) if p1: p1 = 0 else: p1 = pp1 return arr.astype(float)

def removeSinglePixels(img): ''' img - boolean array remove all pixels that have no neighbour ''' gx = img.shape[0] gy = img.shape[1] for i in range(gx): for j in range(gy): if img[i, j]: found_neighbour = False for ii in range(max(0, i - 1), min(gx, i + 2)): for jj in range(max(0, j - 1), min(gy, j + 2)): if ii == i and jj == j: continue if img[ii, jj]: found_neighbour = True break if found_neighbour: break if not found_neighbour: img[i, j] = 0

def interpolateCircular2dStructuredIDW(grid, mask, kernel=15, power=2, fr=1, fphi=1, cx=0, cy=0): ''' same as interpolate2dStructuredIDW but calculation distance to neighbour using polar coordinates fr, fphi --> weight factors for radian and radius differences cx,cy -> polar center of the array e.g. middle->(sx//2+1,sy//2+1) ''' gx = grid.shape[0] gy = grid.shape[0] #FOR EVERY PIXEL for i in range(gx): for j in range(gy): if mask[i,j]: xmn = i-kernel if xmn < 0: xmn = 0 xmx = i+kernel if xmx > gx: xmx = gx ymn = j-kernel if ymn < 0: ymn = 0 ymx = j+kernel if ymx > gx: ymx = gy sumWi = 0.0 value = 0.0 #radius and radian to polar center: R = ((i-cx)**2+(j-cy)**2)**0.5 PHI = atan2(j-cy, i-cx) #FOR EVERY NEIGHBOUR IN KERNEL for xi in range(xmn,xmx): for yi in range(ymn,ymx): if (xi != i or yi != j) and not mask[xi,yi]: nR = ((xi-cx)**2+(yi-cy)**2)**0.5 dr = R - nR #average radius between both p: midR = 0.5*(R+nR) #radian of neighbour p: nphi = atan2(yi-cy, xi-cx) #relative angle between both points: dphi = min((2*np.pi) - abs(PHI - nphi), abs(PHI - nphi)) dphi*=midR dist = ((fr*dr)**2+(fphi*dphi)**2)**2 wi = 1 / dist**(0.5*power) sumWi += wi value += wi * grid[xi,yi] if sumWi: grid[i,j] = value / sumWi return grid

def interpolate2dStructuredCrossAvg(grid, mask, kernel=15, power=2): ''' ####### usefull if large empty areas need to be filled ''' vals = np.empty(shape=4, dtype=grid.dtype) dist = np.empty(shape=4, dtype=np.uint16) weights = np.empty(shape=4, dtype=np.float32) valid = np.empty(shape=4, dtype=bool) return _calc(grid, mask, power, kernel, vals, dist, weights, valid)

def growPositions(ksize): ''' return all positions around central point (0,0) for a given kernel size positions grow from smallest to biggest distances returns [positions] and [distances] from central cell ''' i = ksize*2+1 kk = np.ones( (i, i), dtype=bool) x,y = np.where(kk) pos = np.empty(shape=(i,i,2), dtype=int) pos[:,:,0]=x.reshape(i,i)-ksize pos[:,:,1]=y.reshape(i,i)-ksize dist = np.fromfunction(lambda x,y: ((x-ksize)**2 +(y-ksize)**2)**0.5, (i,i)) pos = np.dstack( np.unravel_index( np.argsort(dist.ravel()), (i, i)))[0,1:] pos0 = pos[:,0] pos1 = pos[:,1] return pos-ksize, dist[pos0, pos1]

def qImageToArray(qimage, dtype = 'array'): """Convert QImage to numpy.ndarray. The dtype defaults to uint8 for QImage.Format_Indexed8 or `bgra_dtype` (i.e. a record array) for 32bit color images. You can pass a different dtype to use, or 'array' to get a 3D uint8 array for color images.""" result_shape = (qimage.height(), qimage.width()) temp_shape = (qimage.height(), qimage.bytesPerLine() * 8 // qimage.depth()) if qimage.format() in (QtGui.QImage.Format_ARGB32_Premultiplied, QtGui.QImage.Format_ARGB32, QtGui.QImage.Format_RGB32): if dtype == 'rec': dtype = np.dtype({'b': (np.uint8, 0), 'g': (np.uint8, 1), 'r': (np.uint8, 2), 'a': (np.uint8, 3)}) elif dtype == 'array': dtype = np.uint8 result_shape += (4, ) temp_shape += (4, ) elif qimage.format() == QtGui.QImage.Format_Indexed8: dtype = np.uint8 else: raise ValueError("qimage2numpy only supports 32bit and 8bit images") # FIXME: raise error if alignment does not match buf = qimage.bits().asstring(qimage.byteCount()) result = np.frombuffer(buf, dtype).reshape(temp_shape) if result_shape != temp_shape: result = result[:,:result_shape[1]] if qimage.format() == QtGui.QImage.Format_RGB32 and dtype == np.uint8: #case byteorder == 'little' result = result[...,:3] #byteorder == 'big' -> get ARGB result = result[...,::-1] return result

def varYSizeGaussianFilter(arr, stdyrange, stdx=0, modex='wrap', modey='reflect'): ''' applies gaussian_filter on input array but allowing variable ksize in y stdyrange(int) -> maximum ksize - ksizes will increase from 0 to given value stdyrange(tuple,list) -> minimum and maximum size as (mn,mx) stdyrange(np.array) -> all different ksizes in y ''' assert arr.ndim == 2, 'only works on 2d arrays at the moment' s0 = arr.shape[0] #create stdys: if isinstance(stdyrange, np.ndarray): assert len(stdyrange)==s0, '[stdyrange] needs to have same length as [arr]' stdys = stdyrange else: if type(stdyrange) not in (list, tuple): stdyrange = (0,stdyrange) mn,mx = stdyrange stdys = np.linspace(mn,mx,s0) #prepare array for convolution: kx = int(stdx*2.5) kx += 1-kx%2 ky = int(mx*2.5) ky += 1-ky%2 arr2 = extendArrayForConvolution(arr, (kx, ky), modex, modey) #create convolution kernels: inp = np.zeros((ky,kx)) inp[ky//2, kx//2] = 1 kernels = np.empty((s0,ky,kx)) for i in range(s0): stdy = stdys[i] kernels[i] = gaussian_filter(inp, (stdy,stdx)) out = np.empty_like(arr) _2dConvolutionYdependentKernel(arr2, out, kernels) return out

def numbaGaussian2d(psf, sy, sx): ''' 2d Gaussian to be used in numba code ''' ps0, ps1 = psf.shape c0,c1 = ps0//2, ps1//2 ssx = 2*sx**2 ssy = 2*sy**2 for i in range(ps0): for j in range(ps1): psf[i,j]=exp( -( (i-c0)**2/ssy +(j-c1)**2/ssx) ) psf/=psf.sum()

def estimateBackgroundLevel(img, image_is_artefact_free=False, min_rel_size=0.05, max_abs_size=11): ''' estimate background level through finding the most homogeneous area and take its average min_size - relative size of the examined area ''' s0,s1 = img.shape[:2] s = min(max_abs_size, int(max(s0,s1)*min_rel_size)) arr = np.zeros(shape=(s0-2*s, s1-2*s), dtype=img.dtype) #fill arr: _spatialStd(img, arr, s) #most homogeneous area: i,j = np.unravel_index(arr.argmin(), arr.shape) sub = img[int(i+0.5*s):int(i+s*1.5), int(j+s*0.5):int(j+s*1.5)] return np.median(sub)

def EL_Si_module(): ''' returns angular dependent EL emissivity of a PV module calculated of nanmedian(persp-corrected EL module/reference module) published in K. Bedrich: Quantitative Electroluminescence Measurement on PV devices PhD Thesis, 2017 ''' arr = np.array([ [2.5, 1.00281 ], [7.5, 1.00238 ], [12.5, 1.00174], [17.5, 1.00204 ], [22.5, 1.00054 ], [27.5, 0.998255], [32.5, 0.995351], [37.5, 0.991246], [42.5, 0.985304], [47.5, 0.975338], [52.5, 0.960455], [57.5, 0.937544], [62.5, 0.900607], [67.5, 0.844636], [72.5, 0.735028], [77.5, 0.57492 ], [82.5, 0.263214], [87.5, 0.123062] ]) angles = arr[:,0] vals = arr[:,1] vals[vals>1]=1 return angles, vals

def TG_glass(): ''' reflected temperature for 250DEG Glass published in IEC 62446-3 TS: Photovoltaic (PV) systems - Requirements for testing, documentation and maintenance - Part 3: Outdoor infrared thermography of photovoltaic modules and plants p Page 12 ''' vals = np.array([(80,0.88), (75,0.88), (70,0.88), (65,0.88), (60,0.88), (55,0.88), (50,0.87), (45,0.86), (40,0.85), (35,0.83), (30,0.80), (25,0.76), (20,0.7), (15,0.60), (10,0.44)]) #invert angle reference: vals[:,0]=90-vals[:,0] #make emissivity relative: vals[:,1]/=vals[0,1] return vals[:,0], vals[:,1]

def sensitivity(imgs, bg=None): ''' Extract pixel sensitivity from a set of homogeneously illuminated images This method is detailed in Section 5 of: --- K.Bedrich, M.Bokalic et al.: ELECTROLUMINESCENCE IMAGING OF PV DEVICES: ADVANCED FLAT FIELD CALIBRATION,2017 --- ''' bg = getBackground(bg) for n, i in enumerate(imgs): i = imread(i, dtype=float) i -= bg smooth = fastMean(median_filter(i, 3)) i /= smooth if n == 0: out = i else: out += i out /= (n + 1) return out

def navierStokes2d(u, v, p, dt, nt, rho, nu, boundaryConditionUV, boundardConditionP, nit=100): ''' solves the Navier-Stokes equation for incompressible flow one a regular 2d grid u,v,p --> initial velocity(u,v) and pressure(p) maps dt --> time step nt --> number of time steps to caluclate rho, nu --> material constants nit --> number of iteration to solve the pressure field ''' #next u, v, p maps: un = np.empty_like(u) vn = np.empty_like(v) pn = np.empty_like(p) #poisson equation ==> laplace term = b[source term] b = np.zeros_like(p) ny,nx = p.shape #cell size: dx = 2 / (nx - 1) dy = 2 / (ny - 1) #next time step: for _ in range(nt): un[:] = u vn[:] = v #pressure _buildB(b, rho, dt, u, v, dx, dy) for _ in range(nit): _pressurePoisson(p, pn, dx, dy, b) boundardConditionP(p) #UV _calcUV(u, v, un, p,vn, dt, dx, dy, rho, nu) boundaryConditionUV(u,v) return u, v, p

def shiftImage(u, v, t, img, interpolation=cv2.INTER_LANCZOS4): ''' remap an image using velocity field ''' ny,nx = u.shape sy, sx = np.mgrid[:float(ny):1,:float(nx):1] sx += u*t sy += v*t return cv2.remap(img.astype(np.float32), (sx).astype(np.float32), (sy).astype(np.float32), interpolation)

def addNoise(img, snr=25, rShot=0.5): ''' adds Gaussian (thermal) and shot noise to [img] [img] is assumed to be noise free [rShot] - shot noise ratio relative to all noise ''' s0, s1 = img.shape[:2] m = img.mean() if np.isnan(m): m = np.nanmean(img) assert m != 0, 'image mean cannot be zero' img = img / m noise = np.random.normal(size=s0 * s1).reshape(s0, s1) if rShot > 0: noise *= (rShot * img**0.5 + 1) noise /= np.nanstd(noise) noise[np.isnan(noise)] = 0 return m * (img + noise / snr)

def coarseMaximum(arr, shape): ''' return an array of [shape] where every cell equals the localised maximum of the given array [arr] at the same (scalled) position ''' ss0, ss1 = shape s0, s1 = arr.shape pos0 = linspace2(0, s0, ss0, dtype=int) pos1 = linspace2(0, s1, ss1, dtype=int) k0 = pos0[0] k1 = pos1[0] out = np.empty(shape, dtype=arr.dtype) _calc(arr, out, pos0, pos1, k0, k1, ss0, ss1) return out

def angleOfView(XY, shape=None, a=None, f=None, D=None, center=None): ''' Another vignetting equation from: M. Koentges, M. Siebert, and D. Hinken, "Quantitative analysis of PV-modules by electroluminescence images for quality control" 2009 f --> Focal length D --> Diameter of the aperture BOTH, D AND f NEED TO HAVE SAME UNIT [PX, mm ...] a --> Angular aperture center -> optical center [y,x] ''' if a is None: assert f is not None and D is not None #https://en.wikipedia.org/wiki/Angular_aperture a = 2*np.arctan2(D/2,f) x,y = XY try: c0,c1 = center except: s0,s1 = shape c0,c1 = s0/2, s1/2 rx = (x-c0)**2 ry = (y-c1)**2 return 1 / (1+np.tan(a)*((rx+ry)/c0))**0.5

def angleOfView2(x,y, b, x0=None,y0=None): ''' Corrected AngleOfView equation by Koentges (via mail from 14/02/2017) b --> distance between the camera and the module in m x0 --> viewable with in the module plane of the camera in m y0 --> viewable height in the module plane of the camera in m x,y --> pixel position [m] from top left ''' if x0 is None: x0 = x[-1,-1] if y0 is None: y0 = y[-1,-1] return np.cos( np.arctan( np.sqrt( ( (x-x0/2)**2+(y-y0/2)**2 ) ) /b ) )

def gridLinesFromVertices(edges, nCells, subgrid=None, dtype=float): """ ###TODO REDO TXT OPTIONAL: subgrid = ([x],[y]) --> relative positions e.g. subgrid = ( (0.3,0.7), () ) --> two subgrid lines in x - nothing in y Returns: horiz,vert -> arrays of (x,y) poly-lines if subgrid != None, Returns: horiz,vert, subhoriz, subvert ####### creates a regular 2d grid from given edge points (4*(x0,y0)) and number of cells in x and y Returns: tuple(4lists): horizontal and vertical lines as (x0,y0,x1,y1) """ nx, ny = nCells y, x = np.mgrid[0.:ny + 1, 0.:nx + 1] src = np.float32([[0, 0], [nx, 0], [nx, ny], [0, ny]]) dst = sortCorners(edges).astype(np.float32) homography = cv2.getPerspectiveTransform(src, dst) pts = np.float32((x.flatten(), y.flatten())).T pts = pts.reshape(1, *pts.shape) pts2 = cv2.perspectiveTransform(pts, homography)[0] horiz = pts2.reshape(ny + 1, nx + 1, 2) vert = np.swapaxes(horiz, 0, 1) subh, subv = [], [] if subgrid is not None: sh, sv = subgrid if len(sh): subh = np.empty(shape=(ny * len(sh), nx + 1, 2), dtype=np.float32) last_si = 0 for n, si in enumerate(sh): spts = pts[:, :-(nx + 1)] spts[..., 1] += si - last_si last_si = si spts2 = cv2.perspectiveTransform(spts, homography)[0] subh[n::len(sh)] = spts2.reshape(ny, nx + 1, 2) if len(sv): subv = np.empty(shape=(ny + 1, nx * len(sv), 2), dtype=np.float32) last_si = 0 sspts = pts.reshape(1, ny + 1, nx + 1, 2) sspts = sspts[:, :, :-1] sspts = sspts.reshape(1, (ny + 1) * nx, 2) for n, si in enumerate(sv): sspts[..., 0] += si - last_si last_si = si spts2 = cv2.perspectiveTransform(sspts, homography)[0] subv[:, n::len(sv)] = spts2.reshape(ny + 1, nx, 2) subv = np.swapaxes(subv, 0, 1) return [horiz, vert, subh, subv]

def MTF50(self, MTFx,MTFy): ''' return object resolution as [line pairs/mm] where MTF=50% see http://www.imatest.com/docs/sharpness/ ''' if self.mtf_x is None: self.MTF() f = UnivariateSpline(self.mtf_x, self.mtf_y-0.5) return f.roots()[0]

def MTF(self, px_per_mm): ''' px_per_mm = cam_resolution / image_size ''' res = 100 #numeric resolution r = 4 #range +-r*std #size of 1 px: px_size = 1 / px_per_mm #standard deviation of the point-spread-function (PSF) as normal distributed: std = self.std*px_size #transform standard deviation from [px] to [mm] x = np.linspace(-r*std,r*std, res) #line spread function: lsf = self.gaussian1d(x, 1, 0, std) #MTF defined as Fourier transform of the line spread function: #abs() because result is complex y = abs(np.fft.fft(lsf)) #normalize fft so that max = 1 y /= np.max(y) #step length between xn and xn+1 dstep = r*std/res # Fourier frequencies - here: line pairs(cycles) per mm freq = np.fft.fftfreq(lsf.size, dstep) #limit mtf between [0-px_per_mm]: i = np.argmax(freq>px_per_mm) self.mtf_x = freq[:i] self.mtf_y = y[:i] return self.mtf_x, self.mtf_y

def uncertaintyMap(self, psf, method='convolve', fitParams=None): ''' return the intensity based uncertainty due to the unsharpness of the image as standard deviation method = ['convolve' , 'unsupervised_wiener'] latter one also returns the reconstructed image (deconvolution) ''' #ignore background: #img[img<0]=0 ###noise should not influence sharpness uncertainty: ##img = median_filter(img, 3) # decrease noise in order not to overestimate result: img = scaleSignal(self.img, fitParams=fitParams) if method == 'convolve': #print 'convolve' blurred = convolve2d(img, psf, 'same') m = abs(img-blurred) / abs(img + blurred) m = np.nan_to_num(m) m*=self.std**2 m[m>1]=1 self.blur_distortion = m np.save('blurred', blurred) return m else: restored = unsupervised_wiener(img, psf)[0] m = abs(img-restored) / abs(img + restored) m = np.nan_to_num(m) m*=self.std**2 m[m>1]=1 self.blur_distortion = m return m, restored

def stdDev(self): ''' get the standard deviation from the PSF is evaluated as 2d Gaussian ''' if self._corrPsf is None: self.psf() p = self._corrPsf.copy() mn = p.min() p[p<0.05*p.max()] = mn p-=mn p/=p.sum() x,y = self._psfGridCoords() x = x.flatten() y = y.flatten() guess = (1,1,0) param, _ = curve_fit(self._fn, (x,y), p.flatten(), guess) self._fitParam = param stdx,stdy = param[:2] self._std = (stdx+stdy) / 2 return self._std

def interpolate2dStructuredIDW(grid, mask, kernel=15, power=2, fx=1, fy=1): ''' replace all values in [grid] indicated by [mask] with the inverse distance weighted interpolation of all values within px+-kernel [power] -> distance weighting factor: 1/distance**[power] ''' weights = np.empty(shape=((2*kernel+1,2*kernel+1))) for xi in range(-kernel,kernel+1): for yi in range(-kernel,kernel+1): dist = ((fx*xi)**2+(fy*yi)**2) if dist: weights[xi+kernel,yi+kernel] = 1 / dist**(0.5*power) return _calc(grid, mask, kernel, weights)

def temporalSignalStability(imgs, times, down_scale_factor=1): ''' (Electroluminescence) signal is not stable over time especially next to cracks. This function takes a set of images and returns parameters, needed to transform uncertainty to other exposure times using [adjustUncertToExposureTime] return [signal uncertainty] obtained from linear fit to [imgs] [average event length] [ascent],[offset] of linear fit -------- [imgs] --> corrected EL images captured in sequence [times] --> absolute measurement times of all [imgs] e.g. every image was taken every 60 sec, then times=60,120,180... [down_scale_factor] --> down scale [imgs] to speed up process ------- More information can be found at ... ---- K.Bedrich: Quantitative Electroluminescence Imaging, PhD Thesis, 2017 Subsection 5.1.4.3: Exposure Time Dependency ---- ''' imgs = np.asarray(imgs) s0, s1, s2 = imgs.shape #down scale imgs to speed up process: if down_scale_factor > 1: s1 //= down_scale_factor s2 //= down_scale_factor imgs2 = np.empty(shape=(s0, s1, s2)) for n, c in enumerate(imgs): imgs2[n] = cv2.resize(c, (s2, s1), interpolation=cv2.INTER_AREA) imgs = imgs2 # linear fit for every point in image set: ascent, offset, error = linRegressUsingMasked2dArrays( times, imgs, calcError=True) # functionally obtained [imgs]: fn_imgs = np.array([offset + t * ascent for t in times]) #difference between [imgs] for fit result: diff = imgs - fn_imgs diff = median_filter(diff, 5) error_t = np.tile(error, (s0, 1, 1)) # find events: evt = (np.abs(diff) > 0.5 * error_t) # calc average event length: avlen = _calcAvgLen(evt, np.empty(shape=evt.shape[1:])) #cannot calc event length smaller exposure time, so: i = avlen == 0 avlen = maskedFilter(avlen, mask=i, fn='mean', ksize=7, fill_mask=False) # remove single px: i = maximum_filter(i, 3) avlen[i] = 0 avlen = maximum_filter(avlen, 3) i = avlen == 0 avlen = median_filter(avlen, 3) avlen[i] = 0 return error, avlen, ascent, offset

def vignettingFromSpotAverage( images, bgImages=None, averageSpot=True, thresh=None): ''' [images] --> list of images containing small bright spots generated by the same device images at different positions within image plane depending on the calibrated waveband the device can be a LCD display or PV 1-cell mini module This method is referred as 'Method B' in --- K.Bedrich, M.Bokalic et al.: ELECTROLUMINESCENCE IMAGING OF PV DEVICES: ADVANCED FLAT FIELD CALIBRATION,2017 --- Args: averageSpot(bool): True: take only the average intensity of each spot thresh(float): marks the minimum spot value (estimated with Otsus method otherwise) Returns: * array to be post processed * image mask containing valid positions ''' fitimg, mask = None, None mx = 0 for c, img in enumerate(images): print('%s/%s' % (c + 1, len(images))) if c == 0: avgBg = getBackground2(bgImages, img) img = imread(img, dtype=float) img -= avgBg # init: if fitimg is None: fitimg = np.zeros_like(img) mask = np.zeros_like(img, dtype=bool) # find spot: if thresh is None: t = threshold_otsu(img) else: t = thresh # take brightest spot spots, n = label(minimum_filter(img > t, 3), background=0, return_num=True) spot_sizes = [(spots == i).sum() for i in range(1, n + 1)] try: spot = (spots == np.argmax(spot_sizes) + 1) except ValueError: print("couldn't find spot in image") continue if averageSpot: spot = np.rint(center_of_mass(spot)).astype(int) mx2 = img[spot].max() else: mx2 = img[spot].mean() fitimg[spot] = img[spot] mask[spot] = 1 if mx2 > mx: mx = mx2 # scale [0...1]: fitimg /= mx return fitimg, mask

def simulateSytematicError(N_SAMPLES=5, N_IMAGES=10, SHOW_DETECTED_PATTERN=True, # GRAYSCALE=False, HEIGHT=500, PLOT_RESULTS=True, PLOT_ERROR_ARRAY=True, CAMERA_PARAM=None, PERSPECTIVE=True, ROTATION=True, RELATIVE_PATTERN_SIZE=0.5, POSITION=True, NOISE=25, BLUR=(3, 3), PATTERNS=None): ''' Simulates a lens calibration using synthetic images * images are rendered under the given HEIGHT resolution * noise and smoothing is applied * perspective and position errors are applied * images are deformed using the given CAMERA_PARAM * the detected camera parameters are used to calculate the error to the given ones simulation ----------- N_IMAGES -> number of images to take for a camera calibration N_SAMPLES -> number of camera calibrations of each pattern type output -------- SHOW_DETECTED_PATTERN: print each image and detected pattern to screen PLOT_RESULTS: plot boxplots of the mean error and std of the camera parameters PLOT_ERROR_ARRAY: plot position error for the lens correction pattern -------- this simulation tests the openCV standard patterns: chess board, asymmetric and symmetric circles GRAYSCALE: whether to load the pattern as gray scale RELATIVE_PATTERN_SIZE: the relative size of the pattern within the image (0.4->40%) PERSPECTIVE: [True] -> enable perspective distortion ROTATION: [True] -> enable rotation of the pattern BLUR: False or (sizex,sizey), like (3,3) CAMERA_PARAM: camera calibration parameters as [fx,fy,cx,cy,k1,k2,k3,p1,p2] ''' print( 'calculate systematic error of the implemented calibration algorithms') # LOCATION OF PATTERN IMAGES folder = MEDIA_PATH if PATTERNS is None: PATTERNS = ('Chessboard', 'Asymmetric circles', 'Symmetric circles') patterns = OrderedDict(( # n of inner corners ('Chessboard', ((6, 9), 'chessboard_pattern_a3.svg')), ('Asymmetric circles', ((4, 11), 'acircles_pattern_a3.svg')), ('Symmetric circles', ((8, 11), 'circles_pattern_a3.svg')), )) # REMOVE PATTERNS THAT ARE NOT TO BE TESTED: [patterns.pop(key) for key in patterns if key not in PATTERNS] if SHOW_DETECTED_PATTERN: cv2.namedWindow('Pattern', cv2.WINDOW_NORMAL) # number of positive detected patterns: success = [] # list[N_SAMPLES] of random camera parameters fx, fy, cx, cy, k1, k2, k3, p1, p2 = [], [], [], [], [], [], [], [], [] # list[Method, N_SAMPLES] of given-detected parameters: errl, fxl, fyl, cxl, cyl, k1l, k2l, k3l, p1l, p2l = [ ], [], [], [], [], [], [], [], [], [] # list[Method, N_SAMPLES] of magnitude(difference of displacement vector # array): dxl = [] dyl = [] # maintain aspect ratio of din a4, a3...: aspect_ratio_DIN = 2.0**0.5 width = int(round(HEIGHT / aspect_ratio_DIN)) if CAMERA_PARAM is None: CAMERA_PARAM = [ HEIGHT, HEIGHT, HEIGHT / 2, width / 2, 0.0, 0.01, 0.1, 0.01, 0.001] # ???CREATE N DIFFERENT RANDOM LENS ERRORS: for n in range(N_SAMPLES): # TODO: RANDOMIZE CAMERA ERROR?? fx.append(CAMERA_PARAM[0]) # * np.random.uniform(1, 2) ) fy.append(CAMERA_PARAM[1]) # * np.random.uniform(1, 2) ) cx.append(CAMERA_PARAM[2]) # * np.random.uniform(0.9, 1.1) ) cy.append(CAMERA_PARAM[3]) # * np.random.uniform(0.9, 1.1) ) k1.append(CAMERA_PARAM[4]) # + np.random.uniform(-1, 1)*0.1) k2.append(CAMERA_PARAM[5]) # + np.random.uniform(-1, 1)*0.01) p1.append(CAMERA_PARAM[6]) # + np.random.uniform(0, 1)*0.1) p2.append(CAMERA_PARAM[7]) # + np.random.uniform(0, 1)*0.01) k3.append(CAMERA_PARAM[8]) # + np.random.uniform(0, 1)*0.001) L = LensDistortion() # FOR EVERY METHOD: for method, (board_size, filename) in patterns.items(): f = folder.join(filename) # LOAD THE SVG FILE, AND SAVE IT WITH NEW RESOLUTION: svg = QtSvg.QSvgRenderer(f) image = QtGui.QImage(width * 4, HEIGHT * 4, QtGui.QImage.Format_ARGB32) image.fill(QtCore.Qt.white) # Get QPainter that paints to the image painter = QtGui.QPainter(image) svg.render(painter) # Save, image format based on file extension # f = "rendered.png" # image.save(f) # # if GRAYSCALE: # img = cv2.imread(f, cv2.IMREAD_GRAYSCALE) # else: # img = cv2.imread(f) img = qImageToArray(image) success.append([]) fxl.append([]) errl.append([]) fyl.append([]) cxl.append([]) cyl.append([]) k1l.append([]) k2l.append([]) k3l.append([]) p1l.append([]) p2l.append([]) dxl.append([]) dyl.append([]) imgHeight, imgWidth = img.shape[0], img.shape[1] for n in range(N_SAMPLES): L.calibrate(board_size, method) print('SET PARAMS:', fx[n], fy[n], cx[n], cy[n], k1[n], k2[n], k3[n], p1[n], p2[n]) L.setCameraParams( fx[n], fy[n], cx[n], cy[n], k1[n], k2[n], k3[n], p1[n], p2[n]) L._coeffs['shape'] = (imgHeight, imgWidth) hw = imgWidth * 0.5 hh = imgHeight * 0.5 for m in range(N_IMAGES): pts1 = np.float32([[hw, hh + 100], [hw - 100, hh - 100], [hw + 100, hh - 100]]) pts2 = pts1.copy() if ROTATION: rotatePolygon(pts2, np.random.randint(0, 2 * np.pi)) if PERSPECTIVE: # CREATE A RANDOM PERSPECTIVE: pts2 += np.random.randint(-hw * 0.05, hh * 0.05, size=(3, 2)) # MAKE SURE THAT THE PATTERN IS FULLY WITHIN THE IMAGE: pts2 *= RELATIVE_PATTERN_SIZE # MOVE TO THE CENTER pts2[:, 0] += hw * (1 - RELATIVE_PATTERN_SIZE) pts2[:, 1] += hh * (1 - RELATIVE_PATTERN_SIZE) if POSITION: f = ((2 * np.random.rand(2)) - 1) pts2[:, 0] += hw * 0.7 * f[0] * (1 - RELATIVE_PATTERN_SIZE) pts2[:, 1] += hh * 0.7 * f[1] * (1 - RELATIVE_PATTERN_SIZE) # EXEC PERSPECTICE, POSITION, ROTATION: M = cv2.getAffineTransform(pts1, pts2) img_warped = cv2.warpAffine( img, M, (imgWidth, imgHeight), borderValue=(230, 230, 230)) # DOWNSCALE IMAGE AGAIN - UPSCALING AND DOWNSCALING SHOULD BRING THE ERRROR # WARPING DOWN img_warped = cv2.resize(img_warped, (width, HEIGHT)) # CREATE THE LENS DISTORTION: mapx, mapy = L.getDistortRectifyMap(width, HEIGHT) # print 664, mapx.shape img_distorted = cv2.remap( img_warped, mapx, mapy, cv2.INTER_LINEAR, borderValue=(230, 230, 230)) # img_distorted[img_distorted==0]=20 # img_distorted[img_distorted>100]=230 if BLUR: img_distorted = cv2.blur(img_distorted, BLUR) if NOISE: # soften, black and white more gray, and add noise img_distorted = img_distorted.astype(np.int16) img_distorted += (np.random.rand(*img_distorted.shape) * NOISE).astype(img_distorted.dtype) img_distorted = np.clip( img_distorted, 0, 255).astype(np.uint8) # plt.imshow(img_distorted) # plt.show() found = L.addImg(img_distorted) if SHOW_DETECTED_PATTERN and found: img_distorted = L.drawChessboard(img_distorted) cv2.imshow('Pattern', img_distorted) cv2.waitKey(1) success[-1].append(L.findCount) try: L._coeffs = None errl[-1].append(L.coeffs['reprojectionError']) L.correct(img_distorted) c = L.getCameraParams() print('GET PARAMS:', c) fxl[-1].append(fx[n] - c[0]) fyl[-1].append(fy[n] - c[1]) cxl[-1].append(cx[n] - c[2]) cyl[-1].append(cy[n] - c[3]) k1l[-1].append(k1[n] - c[4]) k2l[-1].append(k2[n] - c[5]) k3l[-1].append(k3[n] - c[6]) p1l[-1].append(p1[n] - c[7]) p2l[-1].append(p2[n] - c[8]) if PLOT_ERROR_ARRAY: dx = (mapx - L.mapx) / 2 dy = (mapy - L.mapy) / 2 dxl[-1].append(dx) dyl[-1].append(dy) except NothingFound: print( "Couldn't create a calibration because no patterns were detected") del painter # AVERAGE SAMPLES AND GET STD dx_std, dx_mean = [], [] dy_std, dy_mean = [], [] mag = [] std = [] for patterndx, patterndy in zip(dxl, dyl): x = np.mean(patterndx, axis=0) dx_mean.append(x) y = np.mean(patterndy, axis=0) dy_mean.append(y) x = np.std(patterndx, axis=0) mag.append((x**2 + y**2)**0.5) dx_std.append(x) y = np.std(patterndy, axis=0) dy_std.append(y) std.append((x**2 + y**2)**0.5) # PLOT p = len(patterns) if PLOT_RESULTS: fig, axs = plt.subplots(nrows=2, ncols=5) axs = np.array(axs).ravel() for ax, typ, tname in zip(axs, (success, fxl, fyl, cxl, cyl, k1l, k2l, k3l, p1l, p2l), ('Success rate', 'fx', 'fy', 'cx', 'cy', 'k1', 'k2', 'k3', 'p1', 'p2') ): ax.set_title(tname) # , showmeans=True, meanline=True)#labels=patterns.keys()) ax.boxplot(typ, notch=0, sym='+', vert=1, whis=1.5) # , ha=ha[n]) ax.set_xticklabels(patterns.keys(), rotation=40, fontsize=8) if PLOT_ERROR_ARRAY: mmin = np.min(mag) mmax = np.max(mag) smin = np.min(std) smax = np.max(std) plt.figure() for n, pattern in enumerate(patterns.keys()): plt.subplot(int('2%s%s' % (p, n + 1)), axisbg='g') plt.title(pattern) plt.imshow(mag[n], origin='upper', vmin=mmin, vmax=mmax) if n == p - 1: plt.colorbar(label='Average') plt.subplot(int('2%s%s' % (p, n + p + 1)), axisbg='g') plt.title(pattern) plt.imshow(std[n], origin='upper', vmin=smin, vmax=smax) if n == p - 1: plt.colorbar(label='Standard deviation') fig = plt.figure() fig.suptitle('Individually scaled') for n, pattern in enumerate(patterns.keys()): # downscale - show max 30 arrows each dimension sy, sx = dx_mean[n].shape ix = int(sx / 15) if ix < 1: ix = 1 iy = int(sy / 15) if iy < 1: iy = 1 Y, X = np.meshgrid(np.arange(0, sy, iy), np.arange(0, sx, ix)) plt.subplot(int('2%s%s' % (p, n + 1)), axisbg='g') plt.title(pattern) plt.imshow(mag[n], origin='upper') plt.colorbar() plt.quiver( X, Y, dy_mean[n][::ix, ::iy] * 20, dx_mean[n][::ix, ::iy] * 20) plt.subplot(int('2%s%s' % (p, n + p + 1)), axisbg='g') plt.title(pattern) plt.imshow(std[n], origin='upper') plt.colorbar() # plt.quiver(X,Y,dx_std[n][::ix,::iy]*50, dy_std[n][::ix,::iy]*10) ############################################# fig = plt.figure() fig.suptitle('Spatial uncertainty + deflection') for n, pattern in enumerate(patterns.keys()): L.calibrate(board_size, method) # there is alot of additional calc thats not necassary: L.setCameraParams( fx[0], fy[0], cx[0], cy[0], k1[0], k2[0], k3[0], p1[0], p2[0]) L._coeffs['shape'] = (imgHeight, imgWidth) L._coeffs['reprojectionError'] = np.mean(errl[n]) # deflection_x, deflection_y = L.getDeflection(width, HEIGHT) # deflection_x += dx_mean[n] # deflection_y += dy_mean[n] ux, uy = L.standardUncertainties() plt.subplot(int('2%s%s' % (p, n + 1)), axisbg='g') plt.title(pattern) plt.imshow(mag[n], origin='upper') plt.colorbar() # DEFLECTION plt.subplot(int('2%s%s' % (p, n + p + 1)), axisbg='g') plt.title(pattern) plt.imshow(np.linalg.norm([ux, uy], axis=0), origin='upper') plt.colorbar() # DEFL: VECTORS # downscale - show max 30 arrows each dimension sy, sx = dx_mean[n].shape ix = int(sx / 15) if ix < 1: ix = 1 iy = int(sy / 15) if iy < 1: iy = 1 Y, X = np.meshgrid(np.arange(0, sy, iy), np.arange(0, sx, ix)) plt.quiver(X, Y, ux[::ix, ::iy] * 20, uy[::ix, ::iy] * 20) if PLOT_ERROR_ARRAY or PLOT_RESULTS: plt.show() return dx_mean, dy_mean

def plotSet(imgDir, posExTime, outDir, show_legend, show_plots, save_to_file, ftype): ''' creates plots showing both found GAUSSIAN peaks, the histogram, a smoothed histogram from all images within [imgDir] posExTime - position range of the exposure time in the image name e.g.: img_30s.jpg -> (4,5) outDir - dirname to save the output images show_legend - True/False show_plots - display the result on screen save_to_file - save the result to file ftype - file type of the output images ''' xvals = [] hist = [] peaks = [] exTimes = [] max_border = 0 if not imgDir.exists(): raise Exception("image dir doesn't exist") for n, f in enumerate(imgDir): print(f) try: # if imgDir.join(f).isfile(): img = imgDir.join(f) s = FitHistogramPeaks(img) xvals.append(s.xvals) hist.append(s.yvals) # smoothedHist.append(s.yvals2) peaks.append(s.fitValues()) if s.border() > max_border: max_border = s.plotBorder() exTimes.append(float(f[posExTime[0]:posExTime[1] + 1])) except: pass nx = 2 ny = int(len(hist) // nx) + len(hist) % nx fig, ax = plt.subplots(ny, nx) # flatten 2d-ax list: if nx > 1: ax = [list(i) for i in zip(*ax)] # transpose 2d-list axx = [] for xa in ax: for ya in xa: axx.append(ya) ax = axx for x, h, p, e, a in zip(xvals, hist, peaks, exTimes, ax): a.plot(x, h, label='histogram', thickness=3) # l1 = a.plot(x, s, label='smoothed') for n, pi in enumerate(p): l2 = a.plot(x, pi, label='peak %s' % n, thickness=6) a.set_xlim(xmin=0, xmax=max_border) a.set_title('%s s' % e) # plt.setp([l1,l2], linewidth=2)#, linestyle='--', color='r') # set # both to dashed l1 = ax[0].legend() # loc='upper center', bbox_to_anchor=(0.7, 1.05), l1.draw_frame(False) plt.xlabel('pixel value') plt.ylabel('number of pixels') fig = plt.gcf() fig.set_size_inches(7 * nx, 3 * ny) if save_to_file: p = PathStr(outDir).join('result').setFiletype(ftype) plt.savefig(p, bbox_inches='tight') if show_plots: plt.show()

def flatFieldFromCloseDistance(imgs, bg_imgs=None): ''' Average multiple images of a homogeneous device imaged directly in front the camera lens. if [bg_imgs] are not given, background level is extracted from 1% of the cumulative intensity distribution of the averaged [imgs] This measurement method is referred as 'Method A' in --- K.Bedrich, M.Bokalic et al.: ELECTROLUMINESCENCE IMAGING OF PV DEVICES: ADVANCED FLAT FIELD CALIBRATION,2017 --- ''' img = imgAverage(imgs) bg = getBackground2(bg_imgs, img) img -= bg img = toGray(img) mx = median_filter(img[::10, ::10], 3).max() img /= mx return img

def flatFieldFromCloseDistance2(images, bgImages=None, calcStd=False, nlf=None, nstd=6): ''' Same as [flatFieldFromCloseDistance]. Differences are: ... single-time-effect removal included ... returns the standard deviation of the image average [calcStd=True] Optional: ----------- calcStd -> set to True to also return the standard deviation nlf -> noise level function (callable) nstd -> artefact needs to deviate more than [nstd] to be removed ''' if len(images) > 1: # start with brightest images def fn(img): img = imread(img) s0, s1 = img.shape[:2] # rough approx. of image brightness: return -img[::s0 // 10, ::s1 // 10].min() images = sorted(images, key=lambda i: fn(i)) avgBg = getBackground2(bgImages, images[1]) i0 = imread(images[0], dtype=float) - avgBg i1 = imread(images[1], dtype=float) - avgBg if nlf is None: nlf = oneImageNLF(i0, i1)[0] det = SingleTimeEffectDetection( (i0, i1), nlf, nStd=nstd, calcVariance=calcStd) for i in images[1:]: i = imread(i) # exclude erroneously darker areas: thresh = det.noSTE - nlf(det.noSTE) * nstd mask = i > thresh # filter STE: det.addImage(i, mask) ma = det.noSTE else: ma = imread(images[0], dtype=float) - avgBg # fast artifact free maximum: mx = median_filter(ma[::10, ::10], 3).max() if calcStd: return ma / mx, det.mma.var**0.5 / mx return ma / mx

def SNR_hinken(imgs, bg=0, roi=None): ''' signal-to-noise ratio (SNR) as mean(images) / std(images) as defined in Hinken et.al. 2011 (DOI: 10.1063/1.3541766) works on unloaded images no memory overload if too many images are given ''' mean = None M = len(imgs) if bg is not 0: bg = imread(bg)[roi] if roi is not None: bg = bg[roi] #calc mean: for i in imgs: img = imread(i).asfarray() if roi is not None: img = img[roi] img -= bg if mean is None: #init mean = np.zeros_like(img) std = np.zeros_like(img) mean += img del img mean /= M #calc std of mean: for i in imgs: img = imread(i).asfarray() if roi is not None: img = img[roi] img -= bg std += (mean - img)**2 del img std = (std / M)**0.5 return mean.mean() / std.mean()

def boolMasksToImage(masks): ''' Transform at maximum 8 bool layers --> 2d arrays, dtype=(bool,int) to one 8bit image ''' assert len(masks) <= 8, 'can only transform up to 8 masks into image' masks = np.asarray(masks, dtype=np.uint8) assert masks.ndim == 3, 'layers need to be stack of 2d arrays' return np.packbits(masks, axis=0)[0].T

def imageToBoolMasks(arr): '''inverse of [boolMasksToImage]''' assert arr.dtype == np.uint8, 'image needs to be dtype=uint8' masks = np.unpackbits(arr).reshape(*arr.shape, 8) return np.swapaxes(masks, 2, 0)

def calcAspectRatioFromCorners(corners, in_plane=False): ''' simple and better alg. than below in_plane -> whether object has no tilt, but only rotation and translation ''' q = corners l0 = [q[0, 0], q[0, 1], q[1, 0], q[1, 1]] l1 = [q[0, 0], q[0, 1], q[-1, 0], q[-1, 1]] l2 = [q[2, 0], q[2, 1], q[3, 0], q[3, 1]] l3 = [q[2, 0], q[2, 1], q[1, 0], q[1, 1]] a1 = line.length(l0) / line.length(l1) a2 = line.length(l2) / line.length(l3) if in_plane: # take aspect ration from more rectangular corner if (abs(0.5 * np.pi - abs(line.angle2(l0, l1))) < abs(0.5 * np.pi - abs(line.angle2(l2, l3)))): return a1 else: return a2 return 0.5 * (a1 + a2)

def putTextAlpha(img, text, alpha, org, fontFace, fontScale, color, thickness): # , lineType=None ''' Extends cv2.putText with [alpha] argument ''' x, y = cv2.getTextSize(text, fontFace, fontScale, thickness)[0] ox, oy = org imgcut = img[oy - y - 3:oy, ox:ox + x] if img.ndim == 3: txtarr = np.zeros(shape=(y + 3, x, 3), dtype=np.uint8) else: txtarr = np.zeros(shape=(y + 3, x), dtype=np.uint8) cv2.putText(txtarr, text, (0, y), fontFace, fontScale, color, thickness=thickness #, lineType=lineType ) cv2.addWeighted(txtarr, alpha, imgcut, 1, 0, imgcut, -1) return img

def fastMean(img, f=10, inplace=False): ''' for bigger ksizes it if often faster to resize an image rather than blur it... ''' s0,s1 = img.shape[:2] ss0 = int(round(s0/f)) ss1 = int(round(s1/f)) small = cv2.resize(img,(ss1,ss0), interpolation=cv2.INTER_AREA) #bigger k = {'interpolation':cv2.INTER_LINEAR} if inplace: k['dst']=img return cv2.resize(small,(s1,s0), **k)

def read(*paths): """Build a file path from *paths* and return the contents.""" try: f_name = os.path.join(*paths) with open(f_name, 'r') as f: return f.read() except IOError: print('%s not existing ... skipping' % f_name) return ''

def averageSameExpTimes(imgs_path): ''' average background images with same exposure time ''' firsts = imgs_path[:2] imgs = imgs_path[2:] for n, i in enumerate(firsts): firsts[n] = np.asfarray(imread(i)) d = DarkCurrentMap(firsts) for i in imgs: i = imread(i) d.addImg(i) return d.map()

def getLinearityFunction(expTimes, imgs, mxIntensity=65535, min_ascent=0.001, ): ''' returns offset, ascent of image(expTime) = offset + ascent*expTime ''' # TODO: calculate [min_ascent] from noise function # instead of having it as variable ascent, offset, error = linRegressUsingMasked2dArrays( expTimes, imgs, imgs > mxIntensity) ascent[np.isnan(ascent)] = 0 # remove low frequent noise: if min_ascent > 0: i = ascent < min_ascent offset[i] += (0.5 * (np.min(expTimes) + np.max(expTimes))) * ascent[i] ascent[i] = 0 return offset, ascent, error

def sortForSameExpTime(expTimes, img_paths): # , excludeSingleImg=True): ''' return image paths sorted for same exposure time ''' d = {} for e, i in zip(expTimes, img_paths): if e not in d: d[e] = [] d[e].append(i) # for key in list(d.keys()): # if len(d[key]) == 1: # print('have only one image of exposure time [%s]' % key) # print('--> exclude that one') # d.pop(key) d = OrderedDict(sorted(d.items())) return list(d.keys()), list(d.values())

def getDarkCurrentAverages(exposuretimes, imgs): ''' return exposure times, image averages for each exposure time ''' x, imgs_p = sortForSameExpTime(exposuretimes, imgs) s0, s1 = imgs[0].shape imgs = np.empty(shape=(len(x), s0, s1), dtype=imgs[0].dtype) for i, ip in zip(imgs, imgs_p): if len(ip) == 1: i[:] = ip[0] else: i[:] = averageSameExpTimes(ip) return x, imgs

def getDarkCurrentFunction(exposuretimes, imgs, **kwargs): ''' get dark current function from given images and exposure times ''' exposuretimes, imgs = getDarkCurrentAverages(exposuretimes, imgs) offs, ascent, rmse = getLinearityFunction(exposuretimes, imgs, **kwargs) return offs, ascent, rmse

def alignImageAlongLine(img, line, height=15, length=None, zoom=1, fast=False, borderValue=0): ''' return a sub image aligned along given line @param img - numpy.2darray input image to get subimage from @param line - list of 2 points [x0,y0,x1,y1]) @param height - height of output array in y @param length - width of output array @param zoom - zoom factor @param fast - speed up calculation using nearest neighbour interpolation @returns transformed image as numpy.2darray with found line as in the middle ''' height = int(round(height)) if height % 2 == 0: # ->is even number height += 1 # only take uneven numbers to have line in middle if length is None: length = int(round(ln.length(line))) hh = (height - 1) ll = (length - 1) # end points of the line: p0 = np.array(line[0:2], dtype=float) p1 = np.array(line[2:], dtype=float) # p2 is above middle of p0,p1: norm = np.array(ln.normal(line)) if not ln.isHoriz(line): norm *= -1 p2 = (p0 + p1) * 0.5 + norm * hh * 0.5 middleY = hh / 2 pp0 = [0, middleY] pp1 = [ll, middleY] pp2 = [ll * 0.5, hh] pts1 = np.array([p0, p1, p2], dtype=np.float32) pts2 = np.array([pp0, pp1, pp2], dtype=np.float32) if zoom != 1: length = int(round(length * zoom)) height = int(round(height * zoom)) pts2 *= zoom # TRANSFORM: M = cv2.getAffineTransform(pts1, pts2) dst = cv2.warpAffine( img, M, (length, height), flags=cv2.INTER_NEAREST if fast else cv2.INTER_LINEAR, borderValue=borderValue) return dst

def positionToIntensityUncertainty(image, sx, sy, kernelSize=None): ''' calculates the estimated standard deviation map from the changes of neighbouring pixels from a center pixel within a point spread function defined by a std.dev. in x and y taken from the (sx, sy) maps sx,sy -> either 2d array of same shape as [image] of single values ''' psf_is_const = not isinstance(sx, np.ndarray) if not psf_is_const: assert image.shape == sx.shape == sy.shape, \ "Image and position uncertainty maps need to have same size" if kernelSize is None: kernelSize = _kSizeFromStd(max(sx.max(), sy.max())) else: assert type(sx) in (int, float) and type(sx) in (int, float), \ "Image and position uncertainty values need to be int OR float" if kernelSize is None: kernelSize = _kSizeFromStd(max(sx, sy)) if image.dtype.kind == 'u': image = image.astype(int) # otherwise stack overflow through uint size = kernelSize // 2 if size < 1: size = 1 kernelSize = 1 + 2 * size # array to be filled by individual psf of every pixel: psf = np.zeros((kernelSize, kernelSize)) # intensity uncertainty as stdev: sint = np.zeros(image.shape) if psf_is_const: _calc_constPSF(image, sint, sx, sy, psf, size) else: _calc_variPSF(image, sint, sx, sy, psf, size) return sint

def _coarsenImage(image, f): ''' seems to be a more precise (but slower) way to down-scale an image ''' from skimage.morphology import square from skimage.filters import rank from skimage.transform._warps import rescale selem = square(f) arri = rank.mean(image, selem=selem) return rescale(arri, 1 / f, order=0)

def positionToIntensityUncertaintyForPxGroup(image, std, y0, y1, x0, x1): ''' like positionToIntensityUncertainty but calculated average uncertainty for an area [y0:y1,x0:x1] ''' fy, fx = y1 - y0, x1 - x0 if fy != fx: raise Exception('averaged area need to be square ATM') image = _coarsenImage(image, fx) k = _kSizeFromStd(std) y0 = int(round(y0 / fy)) x0 = int(round(x0 / fx)) arr = image[y0 - k:y0 + k, x0 - k:x0 + k] U = positionToIntensityUncertainty(arr, std / fx, std / fx) return U[k:-k, k:-k]

def nan_maximum_filter(arr, ksize): ''' same as scipy.filters.maximum_filter but working excluding nans ''' out = np.empty_like(arr) _calc(arr, out, ksize//2) return out

def medianThreshold(img, threshold=0.1, size=3, condition='>', copy=True): ''' set every the pixel value of the given [img] to the median filtered one of a given kernel [size] in case the relative [threshold] is exeeded condition = '>' OR '<' ''' from scipy.ndimage import median_filter indices = None if threshold > 0: blur = np.asfarray(median_filter(img, size=size)) with np.errstate(divide='ignore', invalid='ignore', over='ignore'): if condition == '>': indices = abs((img - blur) / blur) > threshold else: indices = abs((img - blur) / blur) < threshold if copy: img = img.copy() img[indices] = blur[indices] return img, indices

def fastFilter(arr, ksize=30, every=None, resize=True, fn='median', interpolation=cv2.INTER_LANCZOS4, smoothksize=0, borderMode=cv2.BORDER_REFLECT): ''' fn['nanmean', 'mean', 'nanmedian', 'median'] a fast 2d filter for large kernel sizes that also works with nans the computation speed is increased because only 'every'nsth position within the median kernel is evaluated ''' if every is None: every = max(ksize//3, 1) else: assert ksize >= 3*every s0,s1 = arr.shape[:2] ss0 = s0//every every = s0//ss0 ss1 = s1//every out = np.full((ss0+1,ss1+1), np.nan) c = {'median':_calcMedian, 'nanmedian':_calcNanMedian, 'nanmean':_calcNanMean, 'mean':_calcMean, }[fn] ss0,ss1 = c(arr, out, ksize, every) out = out[:ss0,:ss1] if smoothksize: out = gaussian_filter(out, smoothksize) if not resize: return out return cv2.resize(out, arr.shape[:2][::-1], interpolation=interpolation)

def elbin(filename): ''' Read EL images (*.elbin) created by the RELTRON EL Software http://www.reltron.com/Products/Solar.html ''' # arrs = [] labels = [] # These are all exposure times [s] to be selectable: TIMES = (0.3, 0.4, 0.6, 0.8, 1.2, 1.6, 2.4, 3.2, 4.8, 6.4, 9.6, 12.8, 19.2, 25.6, 38.4, 51.2, 76.8, 102.6, 153.6, 204.6, 307.2, 409.8, 614.4, 819., 1228.8, 1638.6, 3276.6, 5400., 8100., 12168., 18216., 27324., 41004., 61488., 92268.) with open(filename, 'rb') as f: # image shape and number: height, width, frames = np.frombuffer(f.read(4 * 3), dtype=np.uint32) arrs = np.empty((frames, width, height), dtype=np.uint16) for i in range(frames): # read header between all frames: current, voltage = np.frombuffer(f.read(8 * 2), dtype=np.float64) i_time = np.frombuffer(f.read(4), dtype=np.uint32)[0] time = TIMES[i_time] # read image: arr = np.frombuffer(f.read(width * height * 2), dtype=np.uint16) arrs[i] = arr.reshape(width, height) # last row is all zeros in all imgs # print arr[:,:-1] # arrs.append(arr) labels.append({'exposure time[s]': time, 'current[A]': current, 'voltage[V]': voltage}) return arrs, labels

def gaussian2d(xy, sx, sy, mx=0, my=0, rho=0, amp=1, offs=0): ''' see http://en.wikipedia.org/wiki/Multivariate_normal_distribution # probability density function of a vector [x,y] sx,sy -> sigma (standard deviation) mx,my: mue (mean position) rho: correlation between x and y ''' x,y = xy return offs+amp*( 1/(2*np.pi*sx*sy*(1-(rho**2))**0.5) * np.exp( (-1/(2*(1-rho**2))) * ( ( (x-mx)**2/sx**2 ) + ( (y-my)**2/sy**2 ) - ( ( 2*rho*(x-mx)*(y-my)) / (sx*sy) ) ) ) )

def fitImg(self, img_rgb): ''' fit perspective and size of the input image to the base image ''' H = self.pattern.findHomography(img_rgb)[0] H_inv = self.pattern.invertHomography(H) s = self.img_orig.shape warped = cv2.warpPerspective(img_rgb, H_inv, (s[1], s[0])) return warped

def scaleSignalCut(img, ratio, nbins=100): ''' scaling img cutting x percent of top and bottom part of histogram ''' start, stop = scaleSignalCutParams(img, ratio, nbins) img = img - start img /= (stop - start) return img

def scaleSignal(img, fitParams=None, backgroundToZero=False, reference=None): ''' scale the image between... backgroundToZero=True -> 0 (average background) and 1 (maximum signal) backgroundToZero=False -> signal+-3std reference -> reference image -- scale image to fit this one returns: scaled image ''' img = imread(img) if reference is not None: # def fn(ii, m,n): # return ii*m+n # curve_fit(fn, img[::10,::10], ref[::10,::10]) low, high = signalRange(img, fitParams) low2, high2 = signalRange(reference) img = np.asfarray(img) ampl = (high2 - low2) / (high - low) img -= low img *= ampl img += low2 return img else: offs, div = scaleParams(img, fitParams, backgroundToZero) img = np.asfarray(img) - offs img /= div print('offset: %s, divident: %s' % (offs, div)) return img

def getBackgroundRange(fitParams): ''' return minimum, average, maximum of the background peak ''' smn, _, _ = getSignalParameters(fitParams) bg = fitParams[0] _, avg, std = bg bgmn = max(0, avg - 3 * std) if avg + 4 * std < smn: bgmx = avg + 4 * std if avg + 3 * std < smn: bgmx = avg + 3 * std if avg + 2 * std < smn: bgmx = avg + 2 * std else: bgmx = avg + std return bgmn, avg, bgmx

def hasBackground(fitParams): ''' compare the height of putative bg and signal peak if ratio if too height assume there is no background ''' signal = getSignalPeak(fitParams) bg = getBackgroundPeak(fitParams) if signal == bg: return False r = signal[0] / bg[0] if r < 1: r = 1 / r return r < 100

def signalMinimum2(img, bins=None): ''' minimum position between signal and background peak ''' f = FitHistogramPeaks(img, bins=bins) i = signalPeakIndex(f.fitParams) spos = f.fitParams[i][1] # spos = getSignalPeak(f.fitParams)[1] # bpos = getBackgroundPeak(f.fitParams)[1] bpos = f.fitParams[i - 1][1] ind = np.logical_and(f.xvals > bpos, f.xvals < spos) try: i = np.argmin(f.yvals[ind]) return f.xvals[ind][i] except ValueError as e: if bins is None: return signalMinimum2(img, bins=400) else: raise e

def signalMinimum(img, fitParams=None, n_std=3): ''' intersection between signal and background peak ''' if fitParams is None: fitParams = FitHistogramPeaks(img).fitParams assert len(fitParams) > 1, 'need 2 peaks so get minimum signal' i = signalPeakIndex(fitParams) signal = fitParams[i] bg = getBackgroundPeak(fitParams) smn = signal[1] - n_std * signal[2] bmx = bg[1] + n_std * bg[2] if smn > bmx: return smn # peaks are overlapping # define signal min. as intersection between both Gaussians def solve(p1, p2): s1, m1, std1 = p1 s2, m2, std2 = p2 a = (1 / (2 * std1**2)) - (1 / (2 * std2**2)) b = (m2 / (std2**2)) - (m1 / (std1**2)) c = (m1**2 / (2 * std1**2)) - (m2**2 / (2 * std2**2)) - \ np.log(((std2 * s1) / (std1 * s2))) return np.roots([a, b, c]) i = solve(bg, signal) try: return i[np.logical_and(i > bg[1], i < signal[1])][0] except IndexError: # this error shouldn't occur... well return max(smn, bmx)

def getSignalParameters(fitParams, n_std=3): ''' return minimum, average, maximum of the signal peak ''' signal = getSignalPeak(fitParams) mx = signal[1] + n_std * signal[2] mn = signal[1] - n_std * signal[2] if mn < fitParams[0][1]: mn = fitParams[0][1] # set to bg return mn, signal[1], mx

def equalizeImage(img, save_path=None, name_additive='_eqHist'): ''' Equalize the histogram (contrast) of an image works with RGB/multi-channel images and flat-arrays @param img - image_path or np.array @param save_path if given output images will be saved there @param name_additive if given this additive will be appended to output images @return output images if input images are numpy.arrays and no save_path is given @return None elsewise ''' if isinstance(img, string_types): img = PathStr(img) if not img.exists(): raise Exception("image path doesn't exist") img_name = img.basename().replace('.', '%s.' % name_additive) if save_path is None: save_path = img.dirname() img = cv2.imread(img) if img.dtype != np.dtype('uint8'): # openCV cannot work with float arrays or uint > 8bit eqFn = _equalizeHistogram else: eqFn = cv2.equalizeHist if len(img.shape) == 3: # multi channel img like rgb for i in range(img.shape[2]): img[:, :, i] = eqFn(img[:, :, i]) else: # grey scale image img = eqFn(img) if save_path: img_name = PathStr(save_path).join(img_name) cv2.imwrite(img_name, img) return img

def _equalizeHistogram(img): ''' histogram equalisation not bounded to int() or an image depth of 8 bit works also with negative numbers ''' # to float if int: intType = None if 'f' not in img.dtype.str: TO_FLOAT_TYPES = {np.dtype('uint8'): np.float16, np.dtype('uint16'): np.float32, np.dtype('uint32'): np.float64, np.dtype('uint64'): np.float64} intType = img.dtype img = img.astype(TO_FLOAT_TYPES[intType], copy=False) # get image deph DEPTH_TO_NBINS = {np.dtype('float16'): 256, # uint8 np.dtype('float32'): 32768, # uint16 np.dtype('float64'): 2147483648} # uint32 nBins = DEPTH_TO_NBINS[img.dtype] # scale to -1 to 1 due to skikit-image restrictions mn, mx = np.amin(img), np.amax(img) if abs(mn) > abs(mx): mx = mn img /= mx img = exposure.equalize_hist(img, nbins=nBins) img *= mx if intType: img = img.astype(intType) return img

def localizedMaximum(img, thresh=0, min_increase=0, max_length=0, dtype=bool): ''' Returns the local maximum of a given 2d array thresh -> if given, ignore all values below that value max_length -> limit length between value has to vary > min_increase >>> a = np.array([[0,1,2,3,2,1,0], \ [0,1,2,2,3,1,0], \ [0,1,1,2,2,3,0], \ [0,1,1,2,1,1,0], \ [0,0,0,1,1,0,0]]) >>> print localizedMaximum(a, dtype=int) [[0 1 1 1 0 1 0] [0 0 0 0 1 0 0] [0 0 0 1 0 1 0] [0 0 1 1 0 1 0] [0 0 0 1 0 0 0]] ''' # because numba cannot create arrays: out = np.zeros(shape=img.shape, dtype=dtype) # first iterate all rows: _calc(img, out, thresh, min_increase, max_length) # that all columns: _calc(img.T, out.T, thresh, min_increase, max_length) return out

def setReference(self, ref): ''' ref ... either quad, grid, homography or reference image quad --> list of four image points(x,y) marking the edges of the quad to correct homography --> h. matrix to correct perspective distortion referenceImage --> image of same object without perspective distortion ''' # self.maps = {} self.quad = None # self.refQuad = None self._camera_position = None self._homography = None self._homography_is_fixed = True # self.tvec, self.rvec = None, None self._pose = None # evaluate input: if isinstance(ref, np.ndarray) and ref.shape == (3, 3): # REF IS HOMOGRAPHY self._homography = ref # REF IS QUAD elif len(ref) == 4: self.quad = sortCorners(ref) # TODO: cleanup # only need to call once - here o = self.obj_points # no property any more # REF IS IMAGE else: self.ref = imread(ref) # self._refshape = ref.shape[:2] self.pattern = PatternRecognition(self.ref) self._homography_is_fixed = False

def distort(self, img, rotX=0, rotY=0, quad=None): ''' Apply perspective distortion ion self.img angles are in DEG and need to be positive to fit into image ''' self.img = imread(img) # fit old image to self.quad: corr = self.correct(self.img) s = self.img.shape if quad is None: wquad = (self.quad - self.quad.mean(axis=0)).astype(float) win_width = s[1] win_height = s[0] # project quad: for n, q in enumerate(wquad): p = Point3D(q[0], q[1], 0).rotateX(-rotX).rotateY(-rotY) p = p.project(win_width, win_height, s[1], s[1]) wquad[n] = (p.x, p.y) wquad = sortCorners(wquad) # scale result so that longest side of quad and wquad are equal w = wquad[:, 0].max() - wquad[:, 0].min() h = wquad[:, 1].max() - wquad[:, 1].min() scale = min(s[1] / w, s[0] / h) # scale: wquad = (wquad * scale).astype(int) else: wquad = sortCorners(quad) wquad -= wquad.min(axis=0) lx = corr.shape[1] ly = corr.shape[0] objP = np.array([ [0, 0], [lx, 0], [lx, ly], [0, ly], ], dtype=np.float32) homography = cv2.getPerspectiveTransform( wquad.astype(np.float32), objP) # distort corr: w = wquad[:, 0].max() - wquad[:, 0].min() h = wquad[:, 1].max() - wquad[:, 1].min() #(int(w),int(h)) dist = cv2.warpPerspective(corr, homography, (int(w), int(h)), flags=cv2.INTER_CUBIC | cv2.WARP_INVERSE_MAP) # move middle of dist to middle of the old quad: bg = np.zeros(shape=s) rmn = (bg.shape[0] / 2, bg.shape[1] / 2) ss = dist.shape mn = (ss[0] / 2, ss[1] / 2) # wquad.mean(axis=0) ref = (int(rmn[0] - mn[0]), int(rmn[1] - mn[1])) bg[ref[0]:ss[0] + ref[0], ref[1]:ss[1] + ref[1]] = dist # finally move quad into right position: self.quad = wquad self.quad += (ref[1], ref[0]) self.img = bg self._homography = None self._poseFromQuad() if self.opts['do_correctIntensity']: tf = self.tiltFactor() if self.img.ndim == 3: for col in range(self.img.shape[2]): self.img[..., col] *= tf else: # tf = np.tile(tf, (1,1,self.img.shape[2])) self.img = self.img * tf return self.img

def correctGrid(self, img, grid): ''' grid -> array of polylines=((p0x,p0y),(p1x,p1y),,,) ''' self.img = imread(img) h = self.homography # TODO: cleanup only needed to get newBorder attr. if self.opts['do_correctIntensity']: self.img = self.img / self._getTiltFactor(self.img.shape) s0, s1 = grid.shape[:2] n0, n1 = s0 - 1, s1 - 1 snew = self._newBorders b = self.opts['border'] sx, sy = (snew[0] - 2 * b) // n0, (snew[1] - 2 * b) // n1 out = np.empty(snew[::-1], dtype=self.img.dtype) def warp(ix, iy, objP, outcut): shape = outcut.shape[::-1] quad = grid[ix:ix + 2, iy:iy + 2].reshape(4, 2)[np.array([0, 2, 3, 1])] hcell = cv2.getPerspectiveTransform( quad.astype(np.float32), objP) cv2.warpPerspective(self.img, hcell, shape, outcut, flags=cv2.INTER_LANCZOS4, **self.opts['cv2_opts']) return quad objP = np.array([[0, 0], [sx, 0], [sx, sy], [0, sy]], dtype=np.float32) # INNER CELLS for ix in range(1, n0 - 1): for iy in range(1, n1 - 1): sub = out[iy * sy + b: (iy + 1) * sy + b, ix * sx + b: (ix + 1) * sx + b] # warp(ix, iy, objP, sub) shape = sub.shape[::-1] quad = grid[ix:ix + 2, iy:iy + 2].reshape(4, 2)[np.array([0, 2, 3, 1])] # print(quad, objP) hcell = cv2.getPerspectiveTransform( quad.astype(np.float32), objP) cv2.warpPerspective(self.img, hcell, shape, sub, flags=cv2.INTER_LANCZOS4, **self.opts['cv2_opts']) # return out # TOP CELLS objP[:, 1] += b for ix in range(1, n0 - 1): warp(ix, 0, objP, out[: sy + b, ix * sx + b: (ix + 1) * sx + b]) # BOTTOM CELLS objP[:, 1] -= b for ix in range(1, n0 - 1): iy = (n1 - 1) y = iy * sy + b x = ix * sx + b warp(ix, iy, objP, out[y: y + sy + b, x: x + sx]) # LEFT CELLS objP[:, 0] += b for iy in range(1, n1 - 1): y = iy * sy + b warp(0, iy, objP, out[y: y + sy, : sx + b]) # RIGHT CELLS objP[:, 0] -= b ix = (n0 - 1) x = ix * sx + b for iy in range(1, n1 - 1): y = iy * sy + b warp(ix, iy, objP, out[y: y + sy, x: x + sx + b]) # BOTTOM RIGHT CORNER warp(n0 - 1, n1 - 1, objP, out[-sy - b - 1:, x: x + sx + b]) # #TOP LEFT CORNER objP += (b, b) warp(0, 0, objP, out[0: sy + b, 0: sx + b]) # TOP RIGHT CORNER objP[:, 0] -= b # x = (n0-1)*sx+b warp(n0 - 1, 0, objP, out[: sy + b, x: x + sx + b]) # #BOTTOM LEFT CORNER objP += (b, -b) warp(0, n1 - 1, objP, out[-sy - b - 1:, : sx + b]) return out

def correct(self, img): ''' ...from perspective distortion: --> perspective transformation --> apply tilt factor (view factor) correction ''' print("CORRECT PERSPECTIVE ...") self.img = imread(img) if not self._homography_is_fixed: self._homography = None h = self.homography if self.opts['do_correctIntensity']: tf = self.tiltFactor() self.img = np.asfarray(self.img) if self.img.ndim == 3: for col in range(self.img.shape[2]): self.img[..., col] /= tf else: self.img = self.img / tf warped = cv2.warpPerspective(self.img, h, self._newBorders[::-1], flags=cv2.INTER_LANCZOS4, **self.opts['cv2_opts']) return warped

def camera_position(self, pose=None): ''' returns camera position in world coordinates using self.rvec and self.tvec from http://stackoverflow.com/questions/14515200/python-opencv-solvepnp-yields-wrong-translation-vector ''' if pose is None: pose = self.pose() t, r = pose return -np.matrix(cv2.Rodrigues(r)[0]).T * np.matrix(t)

def viewAngle(self, **kwargs): ''' calculate view factor between one small and one finite surface vf =1/pi * integral(cos(beta1)*cos(beta2)/s**2) * dA according to VDI heatatlas 2010 p961 ''' v0 = self.cam2PlaneVectorField(**kwargs) # obj cannot be behind camera v0[2][v0[2] < 0] = np.nan _t, r = self.pose() n = self.planeSfN(r) # because of different x,y orientation: n[2] *= -1 # beta2 = vectorAngle(v0, vectorToField(n) ) beta2 = vectorAngle(v0, n) return beta2

def foreground(self, quad=None): '''return foreground (quad) mask''' fg = np.zeros(shape=self._newBorders[::-1], dtype=np.uint8) if quad is None: quad = self.quad else: quad = quad.astype(np.int32) cv2.fillConvexPoly(fg, quad, 1) return fg.astype(bool)

def tiltFactor(self, midpointdepth=None, printAvAngle=False): ''' get tilt factor from inverse distance law https://en.wikipedia.org/wiki/Inverse-square_law ''' # TODO: can also be only def. with FOV, rot, tilt beta2 = self.viewAngle(midpointdepth=midpointdepth) try: angles, vals = getattr( emissivity_vs_angle, self.opts['material'])() except AttributeError: raise AttributeError("material[%s] is not in list of know materials: %s" % ( self.opts['material'], [o[0] for o in getmembers(emissivity_vs_angle) if isfunction(o[1])])) if printAvAngle: avg_angle = beta2[self.foreground()].mean() print('angle: %s DEG' % np.degrees(avg_angle)) # use averaged angle instead of beta2 to not overemphasize correction normEmissivity = np.clip( InterpolatedUnivariateSpline( np.radians(angles), vals)(beta2), 0, 1) return normEmissivity

def standardUncertainties(self, focal_Length_mm, f_number, midpointdepth=1000, focusAtYX=None, # sigma_best_focus=0, # quad_pos_err=0, shape=None, uncertainties=(0, 0)): ''' focusAtXY - image position with is in focus if not set it is assumed that the image middle is in focus sigma_best_focus - standard deviation of the PSF within the best focus (default blur) uncertainties - contibutors for standard uncertainty these need to be perspective transformed to fit the new image shape ''' # TODO: consider quad_pos_error # (also influences intensity corr map) if shape is None: s = self.img.shape else: s = shape # 1. DEFOCUS DUE TO DEPTH OF FIELD ################################## depthMap = self.depthMap(midpointdepth) if focusAtYX is None: # assume image middle is in-focus: focusAtYX = s[0] // 2, s[1] // 2 infocusDepth = depthMap[focusAtYX] depthOfField_blur = defocusThroughDepth( depthMap, infocusDepth, focal_Length_mm, f_number, k=2.335) # 2. INCREAASED PIXEL SIZE DUE TO INTERPOLATION BETWEEN # PIXELS MOVED APARD ###################################################### # index maps: py, px = np.mgrid[0:s[0], 0:s[1]] # warped index maps: wx = cv2.warpPerspective(np.asfarray(px), self.homography, self._newBorders, borderValue=np.nan, flags=cv2.INTER_LANCZOS4) wy = cv2.warpPerspective(np.asfarray(py), self.homography, self._newBorders, borderValue=np.nan, flags=cv2.INTER_LANCZOS4) pxSizeFactorX = 1 / np.abs(np.gradient(wx)[1]) pxSizeFactorY = 1 / np.abs(np.gradient(wy)[0]) # WARP ALL FIELD TO NEW PERSPECTIVE AND MULTIPLY WITH PXSIZE FACTOR: depthOfField_blur = cv2.warpPerspective( depthOfField_blur, self.homography, self._newBorders, borderValue=np.nan, ) # perspective transform given uncertainties: warpedU = [] for u in uncertainties: # warpedU.append([]) # for i in u: # print i, type(i), isinstance(i, np.ndarray) if isinstance(u, np.ndarray) and u.size > 1: u = cv2.warpPerspective(u, self.homography, self._newBorders, borderValue=np.nan, flags=cv2.INTER_LANCZOS4) # *f else: # multiply with area ratio: after/before perspective warp u *= self.areaRatio warpedU.append(u) # given uncertainties after warp: ux, uy = warpedU ux = pxSizeFactorX * (ux**2 + depthOfField_blur**2)**0.5 uy = pxSizeFactorY * (uy**2 + depthOfField_blur**2)**0.5 # TODO: remove depthOfField_blur,fx,fy from return return ux, uy, depthOfField_blur, pxSizeFactorX, pxSizeFactorY

def _poseFromQuad(self, quad=None): ''' estimate the pose of the object plane using quad setting: self.rvec -> rotation vector self.tvec -> translation vector ''' if quad is None: quad = self.quad if quad.ndim == 3: quad = quad[0] # http://answers.opencv.org/question/1073/what-format-does-cv2solvepnp-use-for-points-in/ # Find the rotation and translation vectors. img_pn = np.ascontiguousarray(quad[:, :2], dtype=np.float32).reshape((4, 1, 2)) obj_pn = self.obj_points - self.obj_points.mean(axis=0) retval, rvec, tvec = cv2.solvePnP( obj_pn, img_pn, self.opts['cameraMatrix'], self.opts['distCoeffs'], flags=cv2.SOLVEPNP_P3P # because exactly four points are given ) if not retval: print("Couln't estimate pose") return tvec, rvec

def drawQuad(self, img=None, quad=None, thickness=30): ''' Draw the quad into given img ''' if img is None: img = self.img if quad is None: quad = self.quad q = np.int32(quad) c = int(img.max()) cv2.line(img, tuple(q[0]), tuple(q[1]), c, thickness) cv2.line(img, tuple(q[1]), tuple(q[2]), c, thickness) cv2.line(img, tuple(q[2]), tuple(q[3]), c, thickness) cv2.line(img, tuple(q[3]), tuple(q[0]), c, thickness) return img

def draw3dCoordAxis(self, img=None, thickness=8): ''' draw the 3d coordinate axes into given image if image == False: create an empty image ''' if img is None: img = self.img elif img is False: img = np.zeros(shape=self.img.shape, dtype=self.img.dtype) else: img = imread(img) # project 3D points to image plane: # self.opts['obj_width_mm'], self.opts['obj_height_mm'] w, h = self.opts['new_size'] axis = np.float32([[0.5 * w, 0.5 * h, 0], [w, 0.5 * h, 0], [0.5 * w, h, 0], [0.5 * w, 0.5 * h, -0.5 * w]]) t, r = self.pose() imgpts = cv2.projectPoints(axis, r, t, self.opts['cameraMatrix'], self.opts['distCoeffs'])[0] mx = int(img.max()) origin = tuple(imgpts[0].ravel()) cv2.line(img, origin, tuple(imgpts[1].ravel()), (0, 0, mx), thickness) cv2.line(img, origin, tuple(imgpts[2].ravel()), (0, mx, 0), thickness) cv2.line( img, origin, tuple(imgpts[3].ravel()), (mx, 0, 0), thickness * 2) return img

def _calcQuadSize(corners, aspectRatio): ''' return the size of a rectangle in perspective distortion in [px] DEBUG: PUT THAT BACK IN??:: if aspectRatio is not given is will be determined ''' if aspectRatio > 1: # x is bigger -> reduce y x_length = PerspectiveCorrection._quadXLength(corners) y = x_length / aspectRatio return x_length, y else: # y is bigger -> reduce x y_length = PerspectiveCorrection._quadYLength(corners) x = y_length * aspectRatio return x, y_length

def linearToPolar(img, center=None, final_radius=None, initial_radius=None, phase_width=None, interpolation=cv2.INTER_AREA, maps=None, borderValue=0, borderMode=cv2.BORDER_REFLECT, **opts): ''' map a 2d (x,y) Cartesian array to a polar (r, phi) array using opencv.remap ''' if maps is None: mapY, mapX = linearToPolarMaps(img.shape[:2], center, final_radius, initial_radius, phase_width) else: mapY, mapX = maps o = {'interpolation': interpolation, 'borderValue': borderValue, 'borderMode': borderMode} o.update(opts) return cv2.remap(img, mapY, mapX, **o)

def polarToLinear(img, shape=None, center=None, maps=None, interpolation=cv2.INTER_AREA, borderValue=0, borderMode=cv2.BORDER_REFLECT, **opts): ''' map a 2d polar (r, phi) polar array to a Cartesian (x,y) array using opencv.remap ''' if maps is None: mapY, mapX = polarToLinearMaps(img.shape[:2], shape, center) else: mapY, mapX = maps o = {'interpolation': interpolation, 'borderValue': borderValue, 'borderMode': borderMode} o.update(opts) return cv2.remap(img, mapY, mapX, **o)

def modifiedLaplacian(img): ''''LAPM' algorithm (Nayar89)''' M = np.array([-1, 2, -1]) G = cv2.getGaussianKernel(ksize=3, sigma=-1) Lx = cv2.sepFilter2D(src=img, ddepth=cv2.CV_64F, kernelX=M, kernelY=G) Ly = cv2.sepFilter2D(src=img, ddepth=cv2.CV_64F, kernelX=G, kernelY=M) FM = np.abs(Lx) + np.abs(Ly) return cv2.mean(FM)[0]

def varianceOfLaplacian(img): ''''LAPV' algorithm (Pech2000)''' lap = cv2.Laplacian(img, ddepth=-1)#cv2.cv.CV_64F) stdev = cv2.meanStdDev(lap)[1] s = stdev[0]**2 return s[0]

def tenengrad(img, ksize=3): ''''TENG' algorithm (Krotkov86)''' Gx = cv2.Sobel(img, ddepth=cv2.CV_64F, dx=1, dy=0, ksize=ksize) Gy = cv2.Sobel(img, ddepth=cv2.CV_64F, dx=0, dy=1, ksize=ksize) FM = Gx*Gx + Gy*Gy mn = cv2.mean(FM)[0] if np.isnan(mn): return np.nanmean(FM) return mn

def normalizedGraylevelVariance(img): ''''GLVN' algorithm (Santos97)''' mean, stdev = cv2.meanStdDev(img) s = stdev[0]**2 / mean[0] return s[0]

def linePlot(img, x0, y0, x1, y1, resolution=None, order=3): ''' returns [img] intensity values along line defined by [x0, y0, x1, y1] resolution ... number or data points to evaluate order ... interpolation precision ''' if resolution is None: resolution = int( ((x1-x0)**2 + (y1-y0)**2 )**0.5 ) if order == 0: x = np.linspace(x0, x1, resolution, dtype=int) y = np.linspace(y0, y1, resolution, dtype=int) return img[y, x] x = np.linspace(x0, x1, resolution) y = np.linspace(y0, y1, resolution) return map_coordinates(img, np.vstack((y,x)), order=order)

def flatFieldFromFunction(self): ''' calculate flatField from fitting vignetting function to averaged fit-image returns flatField, average background level, fitted image, valid indices mask ''' fitimg, mask = self._prepare() mask = ~mask s0, s1 = fitimg.shape #f-value, alpha, fx, cx, cy guess = (s1 * 0.7, 0, 1, s0 / 2, s1 / 2) # set assume normal plane - no tilt and rotation: fn = lambda xy, f, alpha, fx, cx, cy: vignetting((xy[0] * fx, xy[1]), f, alpha, cx=cx, cy=cy) # mask = fitimg>0.5 flatfield = fit2dArrayToFn(fitimg, fn, mask=mask, guess=guess, output_shape=self._orig_shape)[0] return flatfield, self.bglevel / self._n, fitimg, mask

def flatFieldFromFit(self): ''' calculate flatField from 2d-polynomal fit filling all high gradient areas within averaged fit-image returns flatField, average background level, fitted image, valid indices mask ''' fitimg, mask = self._prepare() out = fitimg.copy() lastm = 0 for _ in range(10): out = polyfit2dGrid(out, mask, 2) mask = highGrad(out) m = mask.sum() if m == lastm: break lastm = m out = np.clip(out, 0.1, 1) out = resize(out, self._orig_shape, mode='reflect') return out, self.bglevel / self._n, fitimg, mask

def parse_vhdl_file(fname): '''Parse a named VHDL file Args: fname(str): Name of file to parse Returns: Parsed objects. ''' with open(fname, 'rt') as fh: text = fh.read() return parse_vhdl(text)

def parse_vhdl(text): '''Parse a text buffer of VHDL code Args: text(str): Source code to parse Returns: Parsed objects. ''' lex = VhdlLexer name = None kind = None saved_type = None end_param_group = False cur_package = None metacomments = [] parameters = [] param_items = [] generics = [] ports = [] sections = [] port_param_index = 0 last_item = None array_range_start_pos = 0 objects = [] for pos, action, groups in lex.run(text): if action == 'metacomment': realigned = re.sub(r'^#+', lambda m: ' ' * len(m.group(0)), groups[0]) if last_item is None: metacomments.append(realigned) else: last_item.desc = realigned if action == 'section_meta': sections.append((port_param_index, groups[0])) elif action == 'function': kind = 'function' name = groups[0] param_items = [] parameters = [] elif action == 'procedure': kind = 'procedure' name = groups[0] param_items = [] parameters = [] elif action == 'param': if end_param_group: # Complete previous parameters for i in param_items: parameters.append(i) param_items = [] end_param_group = False param_items.append(VhdlParameter(groups[1])) elif action == 'param_type': mode, ptype = groups if mode is not None: mode = mode.strip() for i in param_items: # Set mode and type for all pending parameters i.mode = mode i.data_type = ptype end_param_group = True elif action == 'param_default': for i in param_items: i.default_value = groups[0] elif action == 'end_subprogram': # Complete last parameters for i in param_items: parameters.append(i) if kind == 'function': vobj = VhdlFunction(name, cur_package, parameters, groups[0], metacomments) else: vobj = VhdlProcedure(name, cur_package, parameters, metacomments) objects.append(vobj) metacomments = [] parameters = [] param_items = [] kind = None name = None elif action == 'component': kind = 'component' name = groups[0] generics = [] ports = [] param_items = [] sections = [] port_param_index = 0 elif action == 'generic_param': param_items.append(groups[0]) elif action == 'generic_param_type': ptype = groups[0] for i in param_items: generics.append(VhdlParameter(i, 'in', ptype)) param_items = [] last_item = generics[-1] elif action == 'port_param': param_items.append(groups[0]) port_param_index += 1 elif action == 'port_param_type': mode, ptype = groups for i in param_items: ports.append(VhdlParameter(i, mode, ptype)) param_items = [] last_item = ports[-1] elif action == 'port_array_param_type': mode, ptype = groups array_range_start_pos = pos[1] elif action == 'array_range_end': arange = text[array_range_start_pos:pos[0]+1] for i in param_items: ports.append(VhdlParameter(i, mode, ptype + arange)) param_items = [] last_item = ports[-1] elif action == 'end_component': vobj = VhdlComponent(name, cur_package, ports, generics, dict(sections), metacomments) objects.append(vobj) last_item = None metacomments = [] elif action == 'package': objects.append(VhdlPackage(groups[0])) cur_package = groups[0] kind = None name = None elif action == 'type': saved_type = groups[0] elif action in ('array_type', 'file_type', 'access_type', 'record_type', 'range_type', 'enum_type', 'incomplete_type'): vobj = VhdlType(saved_type, cur_package, action, metacomments) objects.append(vobj) kind = None name = None metacomments = [] elif action == 'subtype': vobj = VhdlSubtype(groups[0], cur_package, groups[1], metacomments) objects.append(vobj) kind = None name = None metacomments = [] elif action == 'constant': vobj = VhdlConstant(groups[0], cur_package, groups[1], metacomments) objects.append(vobj) kind = None name = None metacomments = [] return objects

def subprogram_prototype(vo): '''Generate a canonical prototype string Args: vo (VhdlFunction, VhdlProcedure): Subprogram object Returns: Prototype string. ''' plist = '; '.join(str(p) for p in vo.parameters) if isinstance(vo, VhdlFunction): if len(vo.parameters) > 0: proto = 'function {}({}) return {};'.format(vo.name, plist, vo.return_type) else: proto = 'function {} return {};'.format(vo.name, vo.return_type) else: # procedure proto = 'procedure {}({});'.format(vo.name, plist) return proto

def subprogram_signature(vo, fullname=None): '''Generate a signature string Args: vo (VhdlFunction, VhdlProcedure): Subprogram object Returns: Signature string. ''' if fullname is None: fullname = vo.name if isinstance(vo, VhdlFunction): plist = ','.join(p.data_type for p in vo.parameters) sig = '{}[{} return {}]'.format(fullname, plist, vo.return_type) else: # procedure plist = ','.join(p.data_type for p in vo.parameters) sig = '{}[{}]'.format(fullname, plist) return sig

def extract_objects_from_source(self, text, type_filter=None): '''Extract object declarations from a text buffer Args: text (str): Source code to parse type_filter (class, optional): Object class to filter results Returns: List of parsed objects. ''' objects = parse_vhdl(text) self._register_array_types(objects) if type_filter: objects = [o for o in objects if isinstance(o, type_filter)] return objects

def is_array(self, data_type): '''Check if a type is a known array type Args: data_type (str): Name of type to check Returns: True if ``data_type`` is a known array type. ''' # Split off any brackets data_type = data_type.split('[')[0].strip() return data_type.lower() in self.array_types

def load_array_types(self, fname): '''Load file of previously extracted data types Args: fname (str): Name of file to load array database from ''' type_defs = '' with open(fname, 'rt') as fh: type_defs = fh.read() try: type_defs = ast.literal_eval(type_defs) except SyntaxError: type_defs = {} self._add_array_types(type_defs)

def save_array_types(self, fname): '''Save array type registry to a file Args: fname (str): Name of file to save array database to ''' type_defs = {'arrays': sorted(list(self.array_types))} with open(fname, 'wt') as fh: pprint(type_defs, stream=fh)

def _register_array_types(self, objects): '''Add array type definitions to internal registry Args: objects (list of VhdlType or VhdlSubtype): Array types to track ''' # Add all array types directly types = [o for o in objects if isinstance(o, VhdlType) and o.type_of == 'array_type'] for t in types: self.array_types.add(t.name) subtypes = {o.name:o.base_type for o in objects if isinstance(o, VhdlSubtype)} # Find all subtypes of an array type for k,v in subtypes.iteritems(): while v in subtypes: # Follow subtypes of subtypes v = subtypes[v] if v in self.array_types: self.array_types.add(k)

def register_array_types_from_sources(self, source_files): '''Add array type definitions from a file list to internal registry Args: source_files (list of str): Files to parse for array definitions ''' for fname in source_files: if is_vhdl(fname): self._register_array_types(self.extract_objects(fname))

def run(self, text): '''Run lexer rules against a source text Args: text (str): Text to apply lexer to Yields: A sequence of lexer matches. ''' stack = ['root'] pos = 0 patterns = self.tokens[stack[-1]] while True: for pat, action, new_state in patterns: m = pat.match(text, pos) if m: if action: #print('## MATCH: {} -> {}'.format(m.group(), action)) yield (pos, m.end()-1), action, m.groups() pos = m.end() if new_state: if isinstance(new_state, int): # Pop states del stack[new_state:] else: stack.append(new_state) #print('## CHANGE STATE:', pos, new_state, stack) patterns = self.tokens[stack[-1]] break else: try: if text[pos] == '\n': pos += 1 continue pos += 1 except IndexError: break

def get_package_version(verfile): '''Scan the script for the version string''' version = None with open(verfile) as fh: try: version = [line.split('=')[1].strip().strip("'") for line in fh if \ line.startswith('__version__')][0] except IndexError: pass return version

def parse_verilog_file(fname): '''Parse a named Verilog file Args: fname (str): File to parse. Returns: List of parsed objects. ''' with open(fname, 'rt') as fh: text = fh.read() return parse_verilog(text)

def parse_verilog(text): '''Parse a text buffer of Verilog code Args: text (str): Source code to parse Returns: List of parsed objects. ''' lex = VerilogLexer name = None kind = None saved_type = None mode = 'input' ptype = 'wire' metacomments = [] parameters = [] param_items = [] generics = [] ports = collections.OrderedDict() sections = [] port_param_index = 0 last_item = None array_range_start_pos = 0 objects = [] for pos, action, groups in lex.run(text): if action == 'metacomment': if last_item is None: metacomments.append(groups[0]) else: last_item.desc = groups[0] if action == 'section_meta': sections.append((port_param_index, groups[0])) elif action == 'module': kind = 'module' name = groups[0] generics = [] ports = collections.OrderedDict() param_items = [] sections = [] port_param_index = 0 elif action == 'parameter_start': net_type, vec_range = groups new_ptype = '' if net_type is not None: new_ptype += net_type if vec_range is not None: new_ptype += ' ' + vec_range ptype = new_ptype elif action == 'param_item': generics.append(VerilogParameter(groups[0], 'in', ptype)) elif action == 'module_port_start': new_mode, net_type, signed, vec_range = groups new_ptype = '' if net_type is not None: new_ptype += net_type if signed is not None: new_ptype += ' ' + signed if vec_range is not None: new_ptype += ' ' + vec_range # Complete pending items for i in param_items: ports[i] = VerilogParameter(i, mode, ptype) param_items = [] if len(ports) > 0: last_item = next(reversed(ports)) # Start with new mode mode = new_mode ptype = new_ptype elif action == 'port_param': ident = groups[0] param_items.append(ident) port_param_index += 1 elif action == 'end_module': # Finish any pending ports for i in param_items: ports[i] = VerilogParameter(i, mode, ptype) vobj = VerilogModule(name, ports.values(), generics, dict(sections), metacomments) objects.append(vobj) last_item = None metacomments = [] return objects