def main(): # объект dtype=float32 f = np.float32(1.0) print('Объект: {}\nТип данных: {}'.format(f, type(f))) # объект np.ndarray, полученный из python списка, с автоматическим определеникм dtype ar = np.array([1, 2, 3]) print('Массив: {}\nТип данных массива (dtype): {}\nТип данных элемента массива: {}'.format(ar, type(ar), type(ar[0]))) # объект np.ndarray, полученный из python списка ar_int32 = np.array([1, 2, 3], dtype=np.int32) print('Массив: {}\nТип данных массива (dtype): {}\nТип данных элемента массива: {}'.format(ar_int32, type(ar_int32), type(ar_int32[0]))) # объект np.ndarray, полученный при помощи конструктора типа dtype i_int = np.int_(10) print('Объект: {}\nТип данных: {}'.format(i_int, type(i_int))) ar_int = np.int_([10, 20, 30]) print('Массив: {}\nТип данных масива (dtype: {}\nТип данных элемента массива: {}'.format(ar_int, type(ar_int), type(ar_int[0]))) ar_bool = np.bool_([0, 1, 0, 0, 1, 1, 1]) print('Тип данных массива: {}'.format(ar_bool.dtype)) ar_int64 = np.array(range(100), dtype=np.int_) print('Тип данных массива: {}'.format(ar_int64.dtype)) ar_float = np.array([1.03, 1, -5.9, 4.6], dtype=np.float16) print('Массив ndarray: {}'.format(ar_float)) print('Тип данных массива: {}'.format(type(ar_float))) ar_scalar = ar_float[3] print('Значение скаляра массива: {}'.format(ar_scalar)) print('Тип данных скаляра массива: {}'.format(ar_scalar.dtype))
def getSuperPixelColorHistogram(superpixels, image): colors = [] #newIm = image numSuperpixels = np.max(superpixels)+1 for i in xrange(0,numSuperpixels): temp = np.zeros((1,64),dtype = float) indices = np.where(superpixels==i) color = image[indices] for j in xrange(0,color.shape[0]): r = np.int_(color[j][0]/0.25) g = np.int_(color[j][1]/0.25) b = np.int_(color[j][2]/0.25) if r ==4: r = 3 if g == 4: g = 3 if b == 4: b = 3 x = 16*r+4*g+b*1 temp[0][x] = temp[0][x]+1 #min_max_scaler = preprocessing.MinMaxScaler() #t = min_max_scaler.fit_transform(temp[0]) #print t colors.append(temp[0]) #showPlots(newIm, numSuperpixels, superpixels) return np.array(colors)
def project_lane_lines(img,left_fitx,right_fitx,yvals): # Create an image to draw the lines on color_warp = np.zeros_like(img).astype(np.uint8) # Recast the x and y points into usable format for cv2.fillPoly() pts_left = np.array([np.transpose(np.vstack([left_fitx, yvals]))]) pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, yvals])))]) pts = np.hstack((pts_left, pts_right)) # Draw the lane onto the warped blank image cv2.polylines(color_warp, np.int_([pts]), isClosed=False, color=(255,0,0), thickness=20) cv2.fillPoly(color_warp, np.int_([pts]), (0,255, 0)) undist = undistort(img) #sp = (550, 310) #ep = (700, 460) #for i in range(4): #center = ((ep[0] + sp[0])/2 , ) #cv2.rectangle(undist, (550, 310), (700, 460), (0,0,255), 4) unwarp,Minv = warp(img,bird_view=False) # Warp the blank back to original image space using inverse perspective matrix (Minv) newwarp = cv2.warpPerspective(color_warp, Minv, (img.shape[1], img.shape[0])) # Combine the result with the original image result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0) return result
def test_contains(self): d = Domain((age, gender, income), metas=(ssn,)) self.assertTrue("AGE" in d) self.assertTrue(age in d) self.assertTrue(0 in d) self.assertTrue(np.int_(0) in d) self.assertTrue("income" in d) self.assertTrue(income in d) self.assertTrue(2 in d) self.assertTrue(np.int_(2) in d) self.assertTrue("SSN" in d) self.assertTrue(ssn in d) self.assertTrue(-1 in d) self.assertTrue(np.int_(-1) in d) self.assertFalse("no_such_thing" in d) self.assertFalse(race in d) self.assertFalse(3 in d) self.assertFalse(np.int_(3) in d) self.assertFalse(-2 in d) self.assertFalse(np.int_(-2) in d) with self.assertRaises(TypeError): {} in d with self.assertRaises(TypeError): [] in d
def el_field(self, X, Q, gamma, nxyz): if self.random_seed != None: np.random.seed(self.random_seed) N = X.shape[0] X[:, 2] = X[:, 2]*gamma XX = np.max(X, axis=0)-np.min(X, axis=0) #XX = XX*np.random.uniform(low=1.0, high=1.1) if self.debug: print( 'mesh steps:', XX) # here we use a fast 3D "near-point" interpolation # we need a stand-alone module with 1D,2D,3D parricles-to-grid functions steps = XX/(nxyz-3) X = X/steps X_min = np.min(X, axis=0) X_mid = np.dot(Q, X)/np.sum(Q) X_off = np.floor(X_min-X_mid) + X_mid X = X - X_off nx = nxyz[0] ny = nxyz[1] nz = nxyz[2] nzny = nz*ny Xi = np.int_(np.floor(X)+1) inds = np.int_(Xi[:, 0]*nzny+Xi[:, 1]*nz+Xi[:, 2]) # 3d -> 1d q = np.bincount(inds, Q, nzny*nx).reshape(nxyz) p = self.potential(q, steps) Ex = np.zeros(p.shape) Ey = np.zeros(p.shape) Ez = np.zeros(p.shape) Ex[:nx-1, :, :] = (p[:nx-1, :, :] - p[1:nx, :, :])/steps[0] Ey[:, :ny-1, :] = (p[:, :ny-1, :] - p[:, 1:ny, :])/steps[1] Ez[:, :, :nz-1] = (p[:, :, :nz-1] - p[:, :, 1:nz])/steps[2] Exyz = np.zeros((N, 3)) Exyz[:, 0] = ndimage.map_coordinates(Ex, np.c_[X[:, 0], X[:, 1]+0.5, X[:, 2]+0.5].T, order=1)*gamma Exyz[:, 1] = ndimage.map_coordinates(Ey, np.c_[X[:, 0]+0.5, X[:, 1], X[:, 2]+0.5].T, order=1)*gamma Exyz[:, 2] = ndimage.map_coordinates(Ez, np.c_[X[:, 0]+0.5, X[:, 1]+0.5, X[:, 2]].T, order=1) return Exyz
def _find_nearest_node_ndarray(rmg, coords, mode='raise'): column_indices = np.int_( np.around((coords[0] - rmg.node_x[0]) / rmg.node_spacing)) row_indices = np.int_( np.around((coords[1] - rmg.node_y[0]) / rmg.node_spacing)) return rmg.grid_coords_to_node_id(row_indices, column_indices, mode=mode)
def mkpDict(period0,nperiod,f,N,ds): periods = [period0] for ip in range(nperiod): periods.append(periods[-1]*(1+f/2)/(1-f/2)) periods = num.array(periods) tdur_vec = num.vectorize(tdur) q = num.int_(num.floor(tdur_vec(ds['rho_s'],ds['b'],periods)/ds['dt'])) tmin = num.floor(periods*(1e0-f/2e0)) tmax = num.ceil(periods*(1e0+f/2e0)) mmin= num.int_(num.floor((N+q-1L)/tmax)) mmax= num.int_(num.floor((N-q)/tmin)+1L) pDdict = {} for ip in range(nperiod): pDdict[ip] = {'q':q[ip], 'tmin':tmin[ip], 'tmax':tmax[ip], 'mmin':mmin[ip], 'mmax':mmax[ip], 'period':periods[ip] } return pDdict, periods, q
def voigtking(v,a): oneonsqrtpi=0.56418958354775630 h0 = np.array([ 1.0e0, 0.9975031223974601240368798e0, 0.9900498337491680535739060e0, 0.9777512371933363639286036e0, 0.9607894391523232094392107e0, 0.9394130628134757861197108e0, 0.9139311852712281867473535e0, 0.8847059049434835594929548e0, 0.8521437889662113384563470e0, 0.8166864825981108401538061e0, 0.7788007830714048682451703e0, 0.7389684882589442416058206e0, 0.6976763260710310572091293e0, 0.6554062543268405127576690e0, 0.6126263941844160689885800e0, 0.5697828247309230097666297e0, 0.5272924240430485572436946e0, 0.4855368951540794399916001e0, 0.4448580662229411344814454e0, 0.4055545050633205516443034e0, 0.3678794411714423215955238e0, 0.3320399453446606420249195e0, 0.2981972794298873779316010e0, 0.2664682978135241116965901e0, 0.2369277586821217567233665e0, 0.2096113871510978225241101e0, 0.1845195239929892676298138e0, 0.1616211924653392539324509e0, 0.1408584209210449961479715e0, 0.1221506695399900084151679e0, 0.1053992245618643367832177e0, 0.9049144166369591062935159e-1, 0.7730474044329974599046566e-1, 0.6571027322750286139200605e-1, 0.5557621261148306865356766e-1, 0.4677062238395898365276137e-1, 0.3916389509898707373977109e-1, 0.3263075599289603180381419e-1, 0.2705184686635041108596167e-1, 0.2231491477696640649487920e-1, 0.1831563888873418029371802e-1, 0.1495813470057748930092482e-1, 0.1215517832991493721502629e-1, 0.9828194835379685936011149e-2, 0.7907054051593440493635646e-2, 0.6329715427485746576865117e-2, 0.5041760259690979102410257e-2, 0.3995845830084632413030896e-2, 0.3151111598444440557819106e-2, 0.2472563035874193226953048e-2, 0.1930454136227709242213512e-2, 0.1499685289329846120368399e-2, 0.1159229173904591150012118e-2, 0.8915937199952195568639939e-3, 0.6823280527563766163014506e-3, 0.5195746821548384817648154e-3, 0.3936690406550782109805393e-3, 0.2967857677932108344855019e-3, 0.2226298569188890101840659e-3, 0.1661698666072774484528398e-3, 0.1234098040866795494976367e-3, 0.9119595636226606575873788e-4, 0.6705482430281108867614262e-4, 0.4905835745620769579106241e-4, 0.3571284964163521691234528e-4, 0.2586810022265412127035909e-4, 0.1864374233151683041526522e-4, 0.1336996212084380475632834e-4, 0.9540162873079234841590110e-5, 0.6773449997703748098370991e-5, 0.4785117392129009089609771e-5, 0.3363595724825637829225185e-5, 0.2352575200009772922652510e-5, 0.1637237807196195233271403e-5, 0.1133727138747965652009438e-5, 0.7811489408304490795473004e-6, 0.5355347802793106157479094e-6, 0.3653171341207511214363159e-6, 0.2479596018045029629499234e-6, 0.1674635703137489046698250e-6, 0.1125351747192591145137752e-6, 0.7524623257644829651017174e-7, 0.5006218020767042215644986e-7, 0.3314082270898834287088712e-7, 0.2182957795125479209083827e-7, 0.1430724191856768833467676e-7, 0.9330287574504991120387842e-8, 0.6054282282484886644264747e-8, 0.3908938434264861859681131e-8, 0.2511212833271291589987176e-8, 0.1605228055185611608653934e-8, 0.1020982947159334870301705e-8, 0.6461431773106108989429857e-9, 0.4068811450655793356678124e-9, 0.2549381880391968872012880e-9, 0.1589391009451636652873474e-9, 0.9859505575991508240729766e-10, 0.6085665105518337082108266e-10, 0.3737571327944262032923964e-10, 0.2284017657993705413027994e-10, 0.1388794386496402059466176e-10, 0.8402431396484308187150245e-11, 0.5058252742843793235026422e-11, 0.3029874246723653849216172e-11, 0.1805831437513215621913785e-11, 0.1070923238250807645586450e-11, 0.6319285885175366663984108e-12, 0.3710275783094727281418983e-12, 0.2167568882618961942307398e-12, 0.1259993054847742150188394e-12, 0.7287724095819692419343177e-13, 0.4194152536192217185131208e-13, 0.2401734781620959445230543e-13, 0.1368467228126496785536523e-13, 0.7758402075696070467242451e-14, 0.4376618502870849893821267e-14, 0.2456595368792144453705261e-14, 0.1372009419645128473380053e-14, 0.7624459905389739760616425e-15, 0.4215893238174252040735029e-15, 0.2319522830243569388312264e-15, 0.1269802641377875575018264e-15, 0.6916753975541448863883054e-16, 0.3748840457745443581785685e-16, 0.2021715848695342027119482e-16, 0.1084855264042937802512215e-16, 0.5792312885394857923477507e-17, 0.3077235638152508657901574e-17, 0.1626664621453244338034305e-17, 0.8555862896902856300749061e-18, 0.4477732441718301199042103e-18, 0.2331744656246116743545942e-18, 0.1208182019899973571654094e-18, 0.6228913128535643653088166e-19, 0.3195366717748344275120932e-19, 0.1631013922670185678641901e-19, 0.8283677007682876110228791e-20, 0.4186173006145967657832773e-20, 0.2104939978339734445589080e-20, 0.1053151347744013743766989e-20, 0.5242885663363463937171805e-21, 0.2597039249246848208769072e-21, 0.1280015319051641983953037e-21, 0.6277407889747195099574399e-22, 0.3063190864577440373821128e-22, 0.1487292181651270619154227e-22, 0.7185335635902193010046941e-23, 0.3454031957013868448981675e-23, 0.1652091782314268593068387e-23, 0.7862678502984538622254116e-24, 0.3723363121750510429289070e-24, 0.1754400713566556605465117e-24, 0.8225280651606668501925640e-25, 0.3837082905344536379879530e-25, 0.1781066634757091357021587e-25, 0.8225980595143903024275237e-26, 0.3780277844776084635218009e-26, 0.1728575244037268289032505e-26, 0.7864685935766448441713277e-27, 0.3560434556451067378310069e-27, 0.1603810890548637852976087e-27, 0.7188393394953158727447087e-28, 0.3205819323394999444158648e-28, 0.1422573701362478490703169e-28, 0.6281148147605989215436687e-29, 0.2759509067522042024589005e-29, 0.1206293927781149203841840e-29, 0.5246902396795390138796640e-30, 0.2270812922026396509517690e-30, 0.9778860615814667663870901e-31, 0.4190093194494397377123780e-31, 0.1786436718517518413888050e-31, 0.7578445267618382646037748e-32, 0.3198903416725805416294188e-32, 0.1343540197758737662452134e-32, 0.5614728092387934579799402e-33, 0.2334722783487267408869808e-33, 0.9659851300583384710233199e-34, 0.3976803097901655265751816e-34, 0.1629019426220514693169818e-34, 0.6639677199580734400702255e-35, 0.2692751000456178970430831e-35, 0.1086610640745980532852592e-35, 0.4362950029268711046345153e-36, 0.1743070896645292498913954e-36, 0.6929124938815710000577778e-37, 0.2740755284722598699701951e-37, 0.1078675105373929991550997e-37, 0.4224152406206200437573993e-38, 0.1645951484063258284098658e-38, 0.6381503448060790393554118e-39, 0.2461826907787885454919214e-39, 0.9449754976491185028813549e-40, 0.3609209642415355020302235e-40, 0.1371614910949353618952282e-40, 0.5186576811908572940413120e-41, 0.1951452380295377748121319e-41, 0.7305730197111493885868359e-42, 0.2721434140093713884466599e-42, 0.1008696596314342558322441e-42, 0.3720075976020835962959696e-43, 0.1365122395620087240477630e-43 ], dtype=np.float64) h1 = np.array([ -1.128379167095512573896159e0, -1.122746665023313894112994e0, -1.105961434222613497822717e0, -1.078356949458362356972974e0, -1.040477963566390226869037e0, -0.9930644092865188274925694e0, -0.9370297574325730524254160e0, -0.8734346738611667009559691e0, -0.8034569860177944012914767e0, -0.7283590897795191457635390e0, -0.6494539941944691013512214e0, -0.5680712138345335512208471e0, -0.4855236771153186839197872e0, -0.4030767281964792012404736e0, -0.3219201665209207840831093e0, -0.2431441002236951675148354e0, -0.1677191974661332963609891e0, -0.9648171389061105293546881e-1, -0.3012346558870770535102483e-1, 0.3081328457047809980986685e-1, 0.8593624458727488433391777e-1, 0.1349991935349749351748713e0, 0.1778942744880748462232135e0, 0.2146410885736963723412265e0, 0.2453732617833523433216744e0, 0.2703231847626659615037426e0, 0.2898056218155761132507312e0, 0.3042008523837261147222841e0, 0.3139379509747736418513567e0, 0.3194787353320834397089635e0, 0.3213028233267945998845488e0, 0.3198941423604233541674753e0, 0.3157291364070343763776039e0, 0.3092668200208504802085382e0, 0.3009407397271468294117335e0, 0.2911528243392948676821857e0, 0.2802690390913659378360681e0, 0.2686167052981096351368975e0, 0.2564833079412283848897372e0, 0.2441165877658165024921633e0, 0.2317257011687522312257119e0, 0.2194832289213470945135105e0, 0.2075278218310246553881156e0, 0.1959672858880207128215797e0, 0.1848819293094190730287360e0, 0.1743280173110208640535652e0, 0.1643412057011470302647273e0, 0.1549398500207542791790132e0, 0.1461281117364874603340094e0, 0.1378988059908943461128856e0, 0.1302359559637753421977543e0, 0.1231170365911391556632533e0, 0.1165149050377156668055896e0, 0.1103994269264874144398788e0, 0.1047388160423518894772002e0, 0.9950071130235648759030670e-1, 0.9465301854781620910441970e-1, 0.9016454652735125189272609e-1, 0.8600546667768981700419079e-1, 0.8214762533231104047151097e-1, 0.7856473513008974607178765e-1, 0.7523246995193424459351750e-1, 0.7212848493340500348466924e-1, 0.6923238018945846374255513e-1, 0.6652562400245432725286132e-1, 0.6399144848312167544450556e-1, 0.6161472819590847810012464e-1, 0.5938184999317344054777048e-1, 0.5728058034957269600588669e-1, 0.5529993483145627029203620e-1, 0.5343005296426139233134751e-1, 0.5166208065197234887486323e-1, 0.4998806142885727821214551e-1, 0.4840083715410895783485349e-1, 0.4689395826338997495993764e-1, 0.4546160333748704598916335e-1, 0.4409850750954268216573793e-1, 0.4279989908392569899980027e-1, 0.4156144366035708515282858e-1, 0.4037919502845779134315796e-1, 0.3924955210570969222557380e-1, 0.3816922122416471946490538e-1, 0.3713518311895684989765586e-1, 0.3614466402785612590311943e-1, 0.3519511037069617482332004e-1, 0.3428416653694949866994660e-1, 0.3340965536664229903158673e-1, 0.3256956096272257612903376e-1, 0.3176201352112533673779090e-1, 0.3098527590780517228496903e-1, 0.3023773174995156695256252e-1, 0.2951787484170619418302355e-1, 0.2882429969333463230632146e-1, 0.2815569307740452259166926e-1, 0.2751082644654734935368337e-1, 0.2688854911528297388431485e-1, 0.2628778211358937241904422e-1, 0.2570751263279204975253415e-1, 0.2514678899527364475073049e-1, 0.2460471608876676259183765e-1, 0.2408045121385331090696902e-1, 0.2357320029997478838776359e-1, 0.2308221445094914570064896e-1, 0.2260678678585010840991674e-1, 0.2214624954526743636682309e-1, 0.2169997143654264861646818e-1, 0.2126735519465680897241377e-1, 0.2084783533811200664569883e-1, 0.2044087610146017752978434e-1, 0.2004596952814515567227767e-1, 0.1966263370908071277476715e-1, 0.1929041115392591487587378e-1, 0.1892886728337045173071115e-1, 0.1857758903193275942486415e-1, 0.1823618355182474294515453e-1, 0.1790427700936730343669473e-1, 0.1758151346626646308038721e-1, 0.1726755383879409857500321e-1, 0.1696207492857163038741910e-1, 0.1666476851923932358834102e-1, 0.1637534053381661837450139e-1, 0.1609351024802744708797459e-1, 0.1581900955528515170398058e-1, 0.1555158227940989996039230e-1, 0.1529098353149220739767610e-1, 0.1503697910762349625920090e-1, 0.1478934492449222808347731e-1, 0.1454786649009525295887101e-1, 0.1431233840704145462214254e-1, 0.1408256390613103046576229e-1, 0.1385835440808103075999097e-1, 0.1363952911143803959964144e-1, 0.1342591460487383719630737e-1, 0.1321734450220107129175951e-1, 0.1301365909857474699723209e-1, 0.1281470504646293252049926e-1, 0.1262033505007755515762735e-1, 0.1243040757705449418533892e-1, 0.1224478658626222948827240e-1, 0.1206334127070085131071308e-1, 0.1188594581452897199141430e-1, 0.1171247916332562864755594e-1, 0.1154282480675818732553606e-1, 0.1137687057288605896976939e-1, 0.1121450843338417065773542e-1, 0.1105563431902001242285305e-1, 0.1090014794476407143162512e-1, 0.1074795264395590657657700e-1, 0.1059895521098731117021612e-1, 0.1045306575200023435008377e-1, 0.1031019754313063242129945e-1, 0.1017026689586042607609242e-1, 0.1003319302906845397201302e-1, 0.9898897947397924639729408e-2, 0.9767306325582547468180475e-2, 0.9638345398396424782187982e-2, 0.9511944855914052317394595e-2, 0.9388036743786533882143785e-2, 0.9266555368258485665416943e-2, 0.9147437205667194364984339e-2, 0.9030620816181499749829423e-2, 0.8916046761552686783940876e-2, 0.8803657526663477808232965e-2, 0.8693397444674087410976982e-2, 0.8585212625576311168220303e-2, 0.8479050887977828363904268e-2, 0.8374861693949366877024963e-2, 0.8272596086777159693185345e-2, 0.8172206631472266686907249e-2, 0.8073647357896888215194357e-2, 0.7976873706375800846399120e-2, 0.7881842475668539112571351e-2, 0.7788511773184966394916599e-2, 0.7696840967333456047851643e-2, 0.7606790641897071224649652e-2, 0.7518322552338916854888971e-2, 0.7431399583943265980411531e-2, 0.7345985711704159367477213e-2, 0.7262045961877964368036759e-2, 0.7179546375120877141317720e-2, 0.7098453971136580788416864e-2, 0.7018736714763248519923831e-2, 0.6940363483432822204243367e-2, 0.6863304035939017881037086e-2, 0.6787528982453825324020280e-2, 0.6713009755735391745310971e-2, 0.6639718583473122562606414e-2, 0.6567628461718606252976457e-2, 0.6496713129353586350126915e-2, 0.6426947043548671526978323e-2, 0.6358305356168803683625031e-2, 0.6290763891083702643557758e-2, 0.6224299122343582476647260e-2, 0.6158888153182396103862750e-2, 0.6094508695812718682782931e-2, 0.6031139051978132847456608e-2, 0.5968758094230636272231571e-2, 0.5907345247902159938278185e-2, 0.5846880473740769223255677e-2, 0.5787344251183524483318654e-2, 0.5728717562239307805652498e-2, 0.5670981875956182433959706e-2 ], dtype=np.float64) h2 = np.array([ 1.0e0, 0.9925156067854728234166954e0, 0.9702488370741846925024279e0, 0.9337524315196362275518164e0, 0.8839262840201373526840738e0, 0.8219864299617913128547470e0, 0.7494235719224071131328299e0, 0.6679529582323300874171809e0, 0.5794577764970237101503160e0, 0.4859284571458759498915146e0, 0.3894003915357024341225852e0, 0.2918925528622829754342991e0, 0.1953493712998886960185562e0, 0.1015879694206602794774387e0, 0.1225252788368832137977160e-1, -0.7122285309136537622082871e-1, -0.1476418787320535960282345e0, -0.2160639183435653507962620e0, -0.2758120010582235033784961e0, -0.3264713765759730440736642e0, -0.3678794411714423215955238e0, -0.4001081341403160736400280e0, -0.4234401367904400766628734e0, -0.4383403499032471637408907e0, -0.4454241863223889026399290e0, -0.4454241976960828728637340e0, -0.4391564671033144569589568e0, -0.4274880540708223266513326e0, -0.4113065890894513887520768e0, -0.3914928958756679769706131e0, -0.3688972859665251787412620e0, -0.3443199355303629399446828e0, -0.3184955306263949534807185e0, -0.2920821644962502188874669e0, -0.2656542962828890681640534e0, -0.2396994397177897912204020e0, -0.2146181451424491640939456e0, -0.1907267687784773058932939e0, -0.1682624875086995569546816e0, -0.1473900121018631148986771e0, -0.1282094722211392620560261e0, -0.1107649874577763082733483e0, -0.9505349453993480902150559e-1, -0.8103346641770551054241192e-1, -0.6863322916783106348475741e-1, -0.5775865327580743751389419e-1, -0.4830006328783957980109026e-1, -0.4013827136320013258889535e-1, -0.3314969401563551466825700e-1, -0.2721055620979549646261829e-1, -0.2220022256661865628545539e-1, -0.1800372189840480267502263e-1, -0.1451354925728548119815172e-1, -0.1163084007733763911929080e-1, -0.9266014956431594449373699e-2, -0.7338992385437093554928018e-2, -0.5779061516816548137194317e-2, -0.4524499030007499171731476e-2, -0.3522004336456824141111923e-2, -0.2726016661692386541868837e-2, -0.2097966669473552341459824e-2, -0.1605504811757694087682580e-2, -0.1221738898797218035679319e-2, -0.9245047462622340271825711e-3, -0.6956863110190540254524861e-3, -0.5205955169809141905659767e-3, -0.3874169656489197360292113e-3, -0.2867188376814953929994613e-3, -0.2110284027525126746959732e-3, -0.1544685271976339753833504e-3, -0.1124502587150317136058296e-3, -0.8141583451940456365639560e-4, -0.5862617398424354123250055e-4, -0.4198696356554642675724513e-4, -0.2990772192017133390000897e-4, -0.2118866502002593128272052e-4, -0.1493070967418717996705171e-4, -0.1046450930688891587354327e-4, -0.7294971485088477169986746e-5, -0.5058237141326785665552064e-5, -0.3488590416297032549927031e-5, -0.2393206427093938070506012e-5, -0.1633028318374209170743394e-5, -0.1108394815502115127316820e-5, -0.7483179321690142728739359e-6, -0.5025418723896900527555212e-6, -0.3357037469306895805115546e-6, -0.2230700306981556484079346e-6, -0.1474451577404705893471723e-6, -0.9694537142843821183145493e-7, -0.6340650817983165854183039e-7, -0.4125281597997292543454039e-7, -0.2669863608647444234432417e-7, -0.1718869397329539903528673e-7, -0.1100823095953252158935162e-7, -0.7013187829205346730804204e-8, -0.4444665113656971914920979e-8, -0.2802144497835918309456751e-8, -0.1757406038399392007880848e-8, -0.1096442676719878283524089e-8, -0.6805092493832370091384262e-9, -0.4201635819811978308984480e-9, -0.2580720549398903308510481e-9, -0.1576898051707325645824557e-9, -0.9585353270320148521118371e-10, -0.5796372027032496381736661e-10, -0.3486981951439767325186431e-10, -0.2086844614201629359434107e-10, -0.1242450483517188985330601e-10, -0.7358989436838238028175315e-11, -0.4336195837012716989509190e-11, -0.2541866144559293225048769e-11, -0.1482350707216456169596291e-11, -0.8600132295160969048704279e-12, -0.4963825648030345884941720e-12, -0.2850272799994640993351100e-12, -0.1628231410435433343915847e-12, -0.9253517530796568988711767e-13, -0.5231904387078439423734991e-13, -0.2942904274907536637035087e-13, -0.1646861209472934265701707e-13, -0.9168609972068950589419375e-14, -0.5078280768842531755862938e-14, -0.2798321959684086361623925e-14, -0.1534077985990025530178263e-14, -0.8366946223931157801875458e-15, -0.4540014839572489640421670e-15, -0.2450864324006565520585709e-15, -0.1316297011679965318337360e-15, -0.7033347094398993022030766e-16, -0.3738906588834781501200156e-16, -0.1977436055729519304364136e-16, -0.1040486355537857239908506e-16, -0.5446873085247993592442947e-17, -0.2836846572016980047452363e-17, -0.1469951297806504842876013e-17, -0.7577907726628295065637298e-18, -0.3886652327556223671914838e-18, -0.1983274447591697794634031e-18, -0.1006865346010664339728430e-18, -0.5085599093462560019056651e-19, -0.2555616473221360979839205e-19, -0.1277711291477349028381922e-19, -0.6355561617974547678564100e-20, -0.3145284379748115775839534e-20, -0.1548642984144385532194339e-20, -0.7586277364385535380007560e-21, -0.3697368508385495481212434e-21, -0.1792850002167444277197814e-21, -0.8649339487208141711410640e-22, -0.4151549880751819128657313e-22, -0.1982560526365887292005855e-22, -0.9419591402219956768405243e-23, -0.4452742857507067242031201e-23, -0.2094178149147388017585982e-23, -0.9799199383965174477667876e-24, -0.4562039303075778937781093e-24, -0.2113096807073358619927786e-24, -0.9738054125666016460529380e-25, -0.4464962955517461045769742e-25, -0.2036839830996770073279630e-25, -0.9244633325579509781433326e-26, -0.4174617922924968276183391e-26, -0.1875592296561359766067593e-26, -0.8384076547424474404764890e-27, -0.3728786627489159285725893e-27, -0.1649968834419055881014869e-27, -0.7264074023243377877657008e-28, -0.3181863066343386789136187e-28, -0.1386691329625598948075213e-28, -0.6012783734099460236172624e-29, -0.2593995437123362612886143e-29, -0.1113425178718492778355866e-29, -0.4755009983792073461050496e-30, -0.2020415749389589696795519e-30, -0.8541405110545145479519840e-31, -0.3592671419230207088768861e-31, -0.1503507555679300913224246e-31, -0.6260283436716785719346509e-32, -0.2593480377514370417261009e-32, -0.1068988029132498238513063e-32, -0.4383933266292682172809914e-33, -0.1788778436796033153181937e-33, -0.7261912176216306101089190e-34, -0.2933239704874698217172402e-34, -0.1178817380216022663848294e-34, -0.4713550938665925243747415e-35, -0.1875222736937308593811831e-35, -0.7422680608185535408905020e-36, -0.2923292133270549875473422e-36, -0.1145479868926911875642964e-36, -0.4465877102072613609496200e-37, -0.1732329082290364039482100e-37, -0.6685880402092324407358875e-38, -0.2567388790315000103954881e-38, -0.9809113395522088573556313e-39, -0.3728835208268407801110216e-39, -0.1410334685901388337197457e-39, -0.5307340860010760817486761e-40, -0.1987182729569070557023125e-40, -0.7402951192281463566289795e-41, -0.2743964271316156357722060e-41 ], dtype=np.float64) h3 = np.array([ -0.7522527780636750492641059e0, -0.7447490315497708463240858e0, -0.7224619689626252165385118e0, -0.6860552061846493969863268e0, -0.6366054955061156295204758e0, -0.5755603365344096850483262e0, -0.5046815829547811446478382e0, -0.4259777864640005624125117e0, -0.3416285184773921405216660e0, -0.2539042236274465364534081e0, -0.1650852727968867264939651e0, -0.7738379667939842709258988e-1, 0.7128394424195324853014844e-2, 0.8658293927736663174097951e-1, 0.1593668102410841966827594e0, 0.2241613263920280449352809e0, 0.2799673824845877680517527e0, 0.3261167006652041288605015e0, 0.3622695948610319801705815e0, 0.3884003473857446343896496e0, 0.4047718038942624860766923e0, 0.4119011753186058824533937e0, 0.4105192820995319949018743e0, 0.4015255845130582620257648e0, 0.3859413195031716183649201e0, 0.3648629230000597762360636e0, 0.3394176769351978836202936e0, 0.3107232057693364099667621e0, 0.2798520840662402744643034e0, 0.2478024303401173430156194e0, 0.2154749773684402246897790e0, 0.1836567467116494732079552e0, 0.1530111326375332319918793e0, 0.1240739307148443832620940e0, 0.9725463688468146271051371e-1, 0.7284219701173870412977577e-1, 0.5101430368585303674221369e-1, 0.3184931174142700893159512e-1, 0.1533986919450959655382290e-1, 0.1407426811309193306581366e-2, -0.1008311291608286074413380e-1, -0.1930922840812282398312132e-1, -0.2647758532035030682089135e-1, -0.3181217775839225922486926e-1, -0.3554404023046894464526427e-1, -0.3790265208183702749516685e-1, -0.3910905737306063850349279e-1, -0.3937064210715186736633504e-1, -0.3887744829978686271653342e-1, -0.3779986028416367095012508e-1, -0.3628747152011772566083547e-1, -0.3446892799961155950489723e-1, -0.3245254463375208029954651e-1, -0.3032750110251363953076864e-1, -0.2816544089164076874994184e-1, -0.2602231914851994604543481e-1, -0.2394036936359898584929537e-1, -0.2195008388641825247433045e-1, -0.2007212746338689903391700e-1, -0.1831912527214265469865516e-1, -0.1669728661861120572688442e-1, -0.1520784216814043766189564e-1, -0.1384828617477219420839203e-1, -0.1261342573197174928239427e-1, -0.1149624682246302216128454e-1, -0.1048861222035593117850278e-1, -0.9581809474549548274726564e-2, -0.8766968673914992518412266e-2, -0.8035369845963356580758239e-2, -0.7378659024311709843220737e-2, -0.6788990545369120409265684e-2, -0.6259111260511144290061333e-2, -0.5782400284632080908741386e-2, -0.5352875804464578036313191e-2, -0.4965178455311671875710459e-2, -0.4614538919616485527188256e-2, -0.4296735750484013517713710e-2, -0.4008047998562558651176877e-2, -0.3745206023826233664801882e-2, -0.3505342894046476979204381e-2, -0.3285947990022833548498951e-2, -0.3084823830238963251792028e-2, -0.2900046668982056656687612e-2, -0.2729931086807768375811907e-2, -0.2572998556853316466871207e-2, -0.2427949813646523181953355e-2, -0.2293640754330915732383722e-2, -0.2169061550185197106672818e-2, -0.2053318626361484792588433e-2, -0.1945619169898585865047079e-2, -0.1845257842557062274985012e-2, -0.1751605400071271234291063e-2, -0.1664098948801722796139379e-2, -0.1582233601544145935191528e-2, -0.1505555324435757496173641e-2, -0.1433654795260900326865144e-2, -0.1366162119305863305428748e-2, -0.1302742271937752484738341e-2, -0.1243091157235637593921277e-2, -0.1186932189400779713774489e-2, -0.1134013318531012910469058e-2, -0.1084104434925714219487149e-2, -0.1036995096671516116549004e-2, -0.9924925341187004927105684e-3, -0.9504198922493585737226438e-3, -0.9106146780909950790852145e-3, -0.8729273854455090856168734e-3, -0.8372202734577421999252958e-3, -0.8033662790881490171689315e-3, -0.7712480465049772662387464e-3, -0.7407570588761368843162862e-3, -0.7117928601052224681383490e-3, -0.6842623557902678206459998e-3, -0.6580791841453911032352388e-3, -0.6331631488616646148452257e-3, -0.6094397069328185150662371e-3, -0.5868395053652243037188589e-3, -0.5652979614557357816469240e-3, -0.5447548819764808379193485e-3, -0.5251541171699206704315699e-3, -0.5064432459446979814905582e-3, -0.4885732890847829717111949e-3, -0.4714984476509869340551945e-3, -0.4551758640732029088500233e-3, -0.4395654037105695480727411e-3, -0.4246294549008608587718018e-3, -0.4103327457346023732872108e-3, -0.3966421759777806984761265e-3, -0.3835266627330082944382909e-3, -0.3709569985755748701109446e-3, -0.3589057210304776810509891e-3, -0.3473469923714317173865229e-3, -0.3362564888248703524021643e-3, -0.3256112983526542094353014e-3, -0.3153898262679901745636708e-3, -0.3055717080111181576022737e-3, -0.2961377284756872027881530e-3, -0.2870697473343167903391904e-3, -0.2783506298634098374691914e-3, -0.2699641828135376810549337e-3, -0.2618950949132550960609061e-3, -0.2541288816315519571599965e-3, -0.2466518338577700959600751e-3, -0.2394509701881161861915701e-3, -0.2325139925352426415436720e-3, -0.2258292448020649292499711e-3, -0.2193856743833149971866920e-3, -0.2131727962785441468085678e-3, -0.2071806596186039850962257e-3, -0.2013998164242456949121338e-3, -0.1958212924305587453675523e-3, -0.1904365598246742268269672e-3, -0.1852375117566223449189077e-3, -0.1802164384945805472907308e-3, -0.1753660051060874920343825e-3, -0.1706792305562262391906103e-3, -0.1661494681223850440721571e-3, -0.1617703870330642541013594e-3, -0.1575359552453832883093564e-3, -0.1534404232825155716084045e-3, -0.1494783090582982775062280e-3, -0.1456443836217787948749789e-3, -0.1419336577595168918308957e-3, -0.1383413693981019940302776e-3, -0.1348629717536061671270311e-3, -0.1314941221786090162018978e-3, -0.1282306716610312631043834e-3, -0.1250686549323268134999138e-3, -0.1220042811456336331711188e-3, -0.1190339250872943430156140e-3, -0.1161541188877486230913414e-3, -0.1133615442001899065679247e-3, -0.1106530248175853517419676e-3, -0.1080255197006960803598953e-3, -0.1054761163916181391183883e-3, -0.1030020247891063146774180e-3, -0.1006005712635544029343839e-3, -0.9826919309099737327798045e-4, -0.9600543318688272806740460e-4, -0.9380693512163903486436983e-4, -0.9167143840125715403094134e-4, -0.8959677399720145006388879e-4, -0.8758086011099098595144745e-4, -0.8562169815974051700802759e-4, -0.8371736896983366064768422e-4, -0.8186602916672109476829247e-4, -0.8006590774959976520266573e-4, -0.7831530284043921555152064e-4, -0.7661257859748228262605498e-4, -0.7495616228396319961002592e-4, -0.7334454148335998246272097e-4, -0.7177626145303295708079228e-4, -0.7024992260860025649833230e-4, -0.6876417813186671874001603e-4, -0.6731773169555726054493046e-4, -0.6590933529851172806481185e-4, -0.6453778720537748581672358e-4, -0.6320192998519050404738797e-4, -0.6190064864356719221383246e-4, -0.6063286884353932444622322e-4, -0.5939755521035460581086281e-4, -0.5819370971583712468698264e-4 ], dtype=np.float64) # Voigt function is symmetric, so -v = v if len(np.argwhere(v<0.0)) != 0: v[np.argwhere(v<0.0)] *= -1.0 # if a is exactly zero go to 3 for exact expression if (a == 0.0): return np.exp(-(v*v)) # Scale up v for ease with lookup tables v0 = v*10.0 n=np.array(v0,dtype=np.int_) voigt_prof = np.zeros(np.size(v)) nl=np.argwhere(n<100) nh=np.argwhere(n>=100) if len(nh) != 0: r=1.0/v[nh]**2 voigt_prof[nh] = a*r*oneonsqrtpi*(1.0 + r*(1.5 + r*(3.75 + r*(13.125 + 59.0625*r))) - a*a*r*(1.0 + r*(5.0 +26.25*r))) if len(nl) != 0: v0[nl] = 2.0*v[nl]*10.0 p=np.int_(v0[nl]) p1=p+1 p2=p+2 x=0.5*np.int_(v0[nl]) y=x+0.5 z=x+1.0 v1 = v0[nl] * 0.5 voigt_prof[nl] = 2.0*((v1-y)*(v1-z)*(h0[p]+a*(h1[p]+a*(h2[p]+a*h3[p]))) - (v1-x)*(v1-z)*2.0*(h0[p1] + a*(h1[p1]+a*(h2[p1]+a*h3[p1]))) + (v1-x)*(v1-y)*(h0[p2] + a*(h1[p2]+a*(h2[p2]+a*h3[p2])))) del nl, nh return voigt_prof
def translate_pix(xpix_rot, ypix_rot, xpos, ypos, scale): # TODO: # Apply a scaling and a translation xpix_translated = np.int_(xpos + xpix_rot / scale) ypix_translated = np.int_(ypos + ypix_rot / scale) # Return the result return xpix_translated, ypix_translated
def Init(self): #boundary and domain condition self.lat = io.read_PETSc_vec(self.config["-Metos3DBoundaryConditionInputDirectory"][0] + self.config["-Metos3DLatitudeFileFormat"][0]) dz = io.read_PETSc_vec(self.config["-Metos3DDomainConditionInputDirectory"][0] + self.config["-Metos3DLayerHeightFileFormat"][0]) z = io.read_PETSc_vec(self.config["-Metos3DDomainConditionInputDirectory"][0] + self.config["-Metos3DLayerDepthFileFormat"][0]) self.lsm = io.read_PETSc_mat(self.config["-Metos3DProfileInputDirectory"][0] + self.config["-Metos3DProfileMaskFile"][0]) self.fice = np.zeros((self.profiles,np.int_(self.config["-Metos3DIceCoverCount"][0])),dtype=np.float_) for i in range(np.int_(self.config["-Metos3DIceCoverCount"][0])): self.fice[:,i] = io.read_PETSc_vec(self.config["-Metos3DBoundaryConditionInputDirectory"][0] + (self.config["-Metos3DIceCoverFileFormat"][0] % i)) self.bc = np.zeros(2,dtype=np.float_) self.dc = np.zeros((self.ny,2),dtype=np.float_) self.dc[:,0] = z self.dc[:,1] = dz self.u = np.array(self.config["-Metos3DParameterValue"],dtype=np.float_) self.dt = np.float_(self.config["-Metos3DTimeStep"][0]) self.nspinup = np.int_(self.config["-Metos3DSpinupCount"][0]) self.ntimestep = np.int_(self.config["-Metos3DTimeStepCount"][0]) self.matrixCount = np.int_(self.config["-Metos3DMatrixCount"][0]) self.U_PODN = np.load(self.config["-Metos3DMatrixInputDirectory"][0] +'N/'+ self.config["-Metos3DMatrixPODFileFormat"][0]) self.U_PODDOP = np.load(self.config["-Metos3DMatrixInputDirectory"][0] +'DOP/'+ self.config["-Metos3DMatrixPODFileFormat"][0]) self.U_DEIMN = np.load(self.config["-Metos3DMatrixInputDirectory"][0] +'N/'+ self.config["-Metos3DMatrixDEIMFileFormat"][0]) self.U_DEIMDOP = np.load(self.config["-Metos3DMatrixInputDirectory"][0] +'DOP/'+ self.config["-Metos3DMatrixDEIMFileFormat"][0]) self.DEIM_IndicesN = np.load(self.config["-Metos3DMatrixInputDirectory"][0] +'N/'+ self.config["-Metos3DDEIMIndicesFileFormat"][0]) self.DEIM_IndicesDOP = np.load(self.config["-Metos3DMatrixInputDirectory"][0] +'DOP/'+ self.config["-Metos3DDEIMIndicesFileFormat"][0]) self.AN = np.ndarray(shape=(self.matrixCount,self.U_PODN.shape[1],self.U_PODN.shape[1]), dtype=np.float_, order='C') self.ADOP = np.ndarray(shape=(self.matrixCount,self.U_PODDOP.shape[1],self.U_PODDOP.shape[1]), dtype=np.float_, order='C') for i in range(0,self.matrixCount): self.AN[i] = np.load(self.config["-Metos3DMatrixInputDirectory"][0] +'N/'+ self.config["-Metos3DMatrixReducedFileFormat"][0] % i) self.ADOP[i] = np.load(self.config["-Metos3DMatrixInputDirectory"][0] +'DOP/'+ self.config["-Metos3DMatrixReducedFileFormat"][0] % i) self.PN = np.ndarray(shape=(self.matrixCount,self.U_PODN.shape[1],self.U_DEIMN.shape[1]), dtype=np.float_, order='C') self.PDOP = np.ndarray(shape=(self.matrixCount,self.U_PODDOP.shape[1],self.U_DEIMDOP.shape[1]), dtype=np.float_, order='C') for i in range(0,self.matrixCount): self.PN[i] = np.load(self.config["-Metos3DMatrixInputDirectory"][0] +'N/'+ self.config["-Metos3DMatrixReducedDEINFileFormat"][0] % i) self.PDOP[i] = np.load(self.config["-Metos3DMatrixInputDirectory"][0] +'DOP/'+ self.config["-Metos3DMatrixReducedDEINFileFormat"][0] % i) #precomputin the interplaton indices for a year [self.interpolation_a,self.interpolation_b,self.interpolation_j,self.interpolation_k] = util.linearinterpolation(2880,12,0.0003472222222222) self.yN = np.ones(self.ny,dtype=np.float_) * np.float_(self.config["-Metos3DTracerInitValue"])[0] self.yDOP = np.ones(self.ny,dtype=np.float_) * np.float_(self.config["-Metos3DTracerInitValue"])[1] self.y_redN = np.dot(self.U_PODN.T,self.yN) self.y_redDOP = np.dot(self.U_PODDOP.T,self.yDOP) self.qN = np.zeros(self.DEIM_IndicesN.shape[0],dtype=np.float_) self.qDOP = np.zeros(self.DEIM_IndicesDOP.shape[0],dtype=np.float_) self.J,self.PJ = util.generateIndicesForNonlinearFunction(self.lsm,self.profiles,self.ny) self.out_pathN = self.config["-Metos3DTracerOutputDirectory"][0] +self.config["-Metos3DSpinupMonitorFileFormatPrefix"][0] + self.config["-Metos3DSpinupMonitorFileFormatPrefix"][1] +self.config["-Metos3DTracerOutputFile"][0] self.out_pathDOP = self.config["-Metos3DTracerOutputDirectory"][0] +self.config["-Metos3DSpinupMonitorFileFormatPrefix"][0] + self.config["-Metos3DSpinupMonitorFileFormatPrefix"][1] +self.config["-Metos3DTracerOutputFile"][1] self.monitor_path = self.config["-Metos3DTracerMointorDirectory"][0] +self.config["-Metos3DSpinupMonitorFileFormatPrefix"][0] + self.config["-Metos3DSpinupMonitorFileFormatPrefix"][1] +self.config["-Metos3DTracerOutputFile"][0]
def indices(self, x, y, clip=False): """ Return the grid pixel indices (i_x, i_y) corresponding to the given arrays of grid coordinates. Arrays x and y must have the same size. Also return a boolean array of the same length that is True where the pixels are within the grid bounds and False elsewhere. If clip is False, a ValueError is raised if any of the pixel centers are outside the grid bounds, and array within will be all True. If clip is True, then the i_x and i_y values where within is False will be nonsense; the safe thing is to use only i_x[within] and i_y[within]. """ if x.size != y.size: raise ValueError("Arrays x and y must have the same length.") # This is a workaround for the behavior of int_: when given an # array of size 1 it returns an int instead of an array. if x.size == 1: i_x = np.array([np.int(np.round((x[0] - self.x[0]) / self.dx()))]) i_y = np.array([np.int(np.round((y[0] - self.y[0]) / self.dy()))]) else: i_x = np.int_(np.round_((x - self.x[0]) / self.dx())) i_y = np.int_(np.round_((y - self.y[0]) / self.dy())) within = ((0 <= i_x) & (i_x < self.x.size) & (0 <= i_y) & (i_y < self.y.size)) if not clip and not all(within): raise ValueError("Not all points are inside the grid bounds, and clipping is not allowed.") return i_x, i_y, within
def initialize(video_capture,rot_angle, pt1, pt2, ppl_width): #read image ret, image = video_capture.read() (hh, ww) = image.shape[:2] #rotate M = None; if (rot_angle != 0): center = (ww / 2, hh / 2) M = cv2.getRotationMatrix2D(center, rot_angle, 1.0) image = imutils.resize(image, width=min(400, image.shape[1])) ##mask after resize resize_ratio = image.shape[1] / float(ww) #max_min_ppl_size ppl_size=[50,100] ppl_size[0] = np.ceil(ppl_width * resize_ratio * 1.4) ppl_size[1] = np.ceil(ppl_width * resize_ratio * 0.8) #print max_ppl_size ROI_1 = np.int_(np.dot(pt1,resize_ratio)) ROI_2 = np.int_(np.dot(pt2,resize_ratio)) return [ww, hh, M, ppl_size, ROI_1, ROI_2]
def get_outliers(art_outliers,motion): import numpy as np import os def try_import(fname): try: a = np.genfromtxt(fname) return a except: return np.array([]) mot = np.genfromtxt(motion) print mot.shape len = mot.shape[0] outliers = try_import(art_outliers) if outliers.shape == (): # 1 outlier art = np.zeros((len, 1)) art[np.int_(outliers), 0] = 1 # art outputs 0 based indices elif outliers.shape[0] == 0: # empty art file art = np.zeros((len, 1)) else: # >1 outlier art = np.zeros((len, outliers.shape[0])) for j, t in enumerate(outliers): art[np.int_(t), j] = 1 # art outputs 0 based indices out_file = os.path.abspath('outliers.txt') np.savetxt(out_file,art) return out_file
def add_pbc_jncol(data,rand): '''If the input is a periodic box and los is along z axis then jacknife region is simply equal area region in the x-y space which can be done in using this function and not needed to be supplied with data file make sure that njn is a perfect square''' #adding jacknife regions if(args.njn>0 and args.los==1): POS_min,POS_max, blen=getminmax(data,rand=rand) NJNx=np.int(np.sqrt(args.njn)) NJNy=np.int(args.njn/NJNx) for ii in (0,2): if(ii==0): mat=data else: mat=rand #get the x and y indx as integers indx=np.int_(NJNx*(mat[:,0]-POS_min[0])/blen[0]) indy=np.int_(NJNy*(mat[:,1]-POS_min[1])/blen[1]) #apply modulo operation on x an y index indx=np.mod(indx,NJNx) indy=np.mod(indy,NJNy) #convert index to integers #indx.astype(np.int64); indy.astype(np.int64); jnreg=NJNy*indx+indy mat=np.column_stack([mat,jnreg]) if(ii==0): data=mat else: rand=mat return data,rand else: print('not appropriate input to add jacknife internally') sys.exit() return 0
def DepositDataToGrid(data, coords, N, hsml, gridres, rmax, griddata): norm = 1.8189136353359467 # 40 / (7 pi) for 2D grid_dx = 2*rmax/(gridres-1) shift_coords = coords[:] + rmax gxmin = np.int_((shift_coords[:,0] - hsml[:])/grid_dx + 0.5) gxmax = np.int_((shift_coords[:,0] + hsml[:])/grid_dx) gymin = np.int_((shift_coords[:,1] - hsml[:])/grid_dx + 0.5) gymax = np.int_((shift_coords[:,1] + hsml[:])/grid_dx) for i in xrange(N): h = hsml[i] mh2 = data[i,:]/h**2 if gxmin[i] < 0: gxmin[i] = 0 if gxmax[i] > gridres - 1: gxmax[i] = gridres - 1 if gymin[i] < 0: gymin[i] = 0 if gymax[i] > gridres - 1: gymax[i] = gridres - 1 for gx in xrange(gxmin[i], gxmax[i]+1): for gy in xrange(gymin[i], gymax[i]+1): q = np.sqrt((shift_coords[i,0] - gx*grid_dx)**2 + (shift_coords[i,1] - gy*grid_dx)**2)/h if q <= 0.5: griddata[gy, gx,:] += (1 - 6*q**2 + 6*q**3) * mh2 elif q <= 1.0: griddata[gy, gx,:] += (2*(1-q)**3) * mh2 griddata[:] = norm*griddata[:]
def get_many_patches(image, patch_shape, centers, flat=True, step=1, force_pure_python=False): """Return the patches at given centers""" patch_shape = tuple(patch_shape) centers = np.reshape(np.asarray(centers, dtype=np.int_), (-1, len(patch_shape))) ndims = len(patch_shape) if ndims in [2,3] and "_get_many_patches" in globals() and not force_pure_python: # 3d version (efficient Cython implementation) patches = _get_many_patches(ndims, image, patch_shape, centers, step) else: # Extract patches (pure Python version) grid_slices = tuple(slice(-(i//2), i-i//2, step) for i in patch_shape) grid = np.reshape(np.mgrid[grid_slices], (len(patch_shape), -1)) points = tuple(np.int_(centers.T[:,:,np.newaxis]) + np.int_(grid[:,np.newaxis,:])) patches = image[points] # Compute the final patch shape taking into acount the step final_shape = tuple((sh - 1)/step + 1 for sh in patch_shape) channels = image.shape[len(patch_shape):] if not flat: patches = np.reshape(patches, (-1,) + tuple(final_shape) + channels) else: patches = np.reshape(patches, (len(patches), np.prod(final_shape + channels))) return patches
def draw(self, dt): if self._mixer.is_onset(): self._offset_z += self.parameter('beat-color-boost').get() angle = self.parameter('angle').get() #self._offset_x += dt * self.parameter('speed').get() * math.cos(angle) * 2 * math.pi #self._offset_y += dt * self.parameter('speed').get() * math.sin(angle) * 2 * math.pi self._offset_x += dt * self.parameter('speed').get() self._offset_z += dt * self.parameter('color-speed').get() posterization = self.parameter('resolution').get() rotMatrix = np.array([(math.cos(angle), -math.sin(angle)), (math.sin(angle), math.cos(angle))]) x,y = rotMatrix.T.dot(self.pixel_locations.T) x *= self.parameter('stretch').get() x += self._offset_x y += self._offset_y locations = np.asarray([x,y]).T hues = np.asarray([snoise3(self.scale * location[0], \ self.scale * location[1], \ self._offset_z, 1, 0.5, 0.5) for location in locations]) hues = (1.0 + hues) / 2 hues = self.hue_min + ((np.int_(hues * posterization) / float(posterization)) * (self.hue_max - self.hue_min)) brights = np.asarray([snoise3(self.luminance_scale * location[0], self.luminance_scale * location[1], self._offset_z, 1, 0.5, 0.5) for location in locations]) brights = (1.0 + brights) / 2 brights *= self._luminance_steps luminances = self.lum_fader.color_cache[np.int_(brights)].T[1] self.setAllHLS(hues, luminances, 1.0)
def DepositDataToGrid3D(data, coords, N, hsml, gridres, rmax, griddata): norm = 2.5464790894703255 #8/np.pi for 3D grid_dx = 2*rmax/(gridres-1) zSqr = coords[:,2]*coords[:,2] hsml_plane = np.sqrt(hsml[:]*hsml[:] - zSqr) shift_coords = coords[:,:2] + rmax gxmin = np.int_((shift_coords[:,0] - hsml_plane[:])/grid_dx + 0.5) gxmax = np.int_((shift_coords[:,0] + hsml_plane[:])/grid_dx) gymin = np.int_((shift_coords[:,1] - hsml_plane[:])/grid_dx + 0.5) gymax = np.int_((shift_coords[:,1] + hsml_plane[:])/grid_dx) for i in xrange(N): h = hsml[i] mh3 = data[i,:]/h**3 z2 = zSqr[i] if gxmin[i] < 0: gxmin[i] = 0 if gxmax[i] > gridres - 1: gxmax[i] = gridres - 1 if gymin[i] < 0: gymin[i] = 0 if gymax[i] > gridres - 1: gymax[i] = gridres - 1 for gx in xrange(gxmin[i], gxmax[i]+1): for gy in xrange(gymin[i], gymax[i]+1): q = np.sqrt((shift_coords[i,0] - gx*grid_dx)**2 + (shift_coords[i,1] - gy*grid_dx)**2 + z2)/h if q <= 0.5: griddata[gy, gx,:] += (1 - 6*q**2 + 6*q**3) * mh3 elif q <= 1.0: griddata[gy, gx,:] += (2*(1-q)**3) * mh3 griddata[:] = norm*griddata[:]
def K(self, X, X2=None): #This way is not working, indexes are lost after using k._slice_X #index = np.asarray(X, dtype=np.int) #index = index.reshape(index.size,) if hasattr(X, 'values'): X = X.values index = np.int_(X[:, 1]) index = index.reshape(index.size,) X_flag = index[0] >= self.output_dim if X2 is None: if X_flag: #Calculate covariance function for the latent functions index -= self.output_dim return self._Kuu(X, index) else: raise NotImplementedError else: #This way is not working, indexes are lost after using k._slice_X #index2 = np.asarray(X2, dtype=np.int) #index2 = index2.reshape(index2.size,) if hasattr(X2, 'values'): X2 = X2.values index2 = np.int_(X2[:, 1]) index2 = index2.reshape(index2.size,) X2_flag = index2[0] >= self.output_dim #Calculate cross-covariance function if not X_flag and X2_flag: index2 -= self.output_dim return self._Kfu(X, index, X2, index2) #Kfu else: index -= self.output_dim return self._Kfu(X2, index2, X, index).T #Kuf
def get_data_set(): data_set = [] categories = {} next_cat_index = 1 first_line = True with open ('original_data/numerai_training_data.csv', 'r') as csvfile: spamreader = csv.reader(csvfile) for row in spamreader: if not first_line: #Skip first line data_set_item = np.int_(row[0:14]).astype(np.int) category = row[14] try: #if KeyError add a new category cat_index = categories[category] except KeyError as e: categories[category] = next_cat_index next_cat_index += 1 cat_index = categories[category] data_set_item = np.append(data_set_item, np.int_([cat_index])) data_set_item = np.append(data_set_item, np.int_(row[15:]).astype(np.int)) data_set.append(data_set_item) else: first_line = False data_set = np.int_(data_set) return (data_set, categories)
def rhopol_to_rhotor(self, time, rhopol): N = numpy.size(rhopol) if self.__status: error = ctypes.c_int(0) _error = ctypes.byref(error) _shotnumber = ctypes.byref(self.__shotnumber) _edition = ctypes.byref(self.__edition) t = ctypes.c_float( time ) _t = ctypes.byref( t ) if N == 1: rhopf = ctypes.c_float(rhopol) if isinstance(rhopol, float) else ctypes.c_float(rhopol[0]) rhot = ctypes.c_float(0) pf = ctypes.c_float(0) fpf = ctypes.c_float(0) ftf = ctypes.c_float(0) else: rhopf = (ctypes.c_float*N)() rhot = (ctypes.c_float*N)() pf = (ctypes.c_float*N)() fpf = (ctypes.c_float*N)() ftf = (ctypes.c_float*N)() for i in range(N): rhopf[i] = rhopol[i] rhot[i] = 0 pf[i] = 0 fpf[i] = 0 ftf[i] = 0 _rhopf = ctypes.byref(rhopf) _rhot = ctypes.byref(rhot) _pf = ctypes.byref(pf) lrho = ctypes.c_int(N) _lrho = ctypes.byref(lrho) _fpf = ctypes.byref(fpf) _ftf = ctypes.byref(ftf) lexper = ctypes.c_long(len(self.experiment)) ldiag = ctypes.c_long(3) libkk.kkrhopto_(_error, self.__exper,self.__diag,_shotnumber,_edition,_t,\ _rhopf, _lrho,\ _rhot,_fpf,_ftf,\ lexper, ldiag) #kkrhopto (&error,exp,diag,&shot,&edition, &time, #rhopf, &lrho, #rhopf, fpf, ftf , strlen(exp), strlen(diag) ); if N == 1: return {'error' : numpy.int_(error),\ 'time' : numpy.float32(t),\ 'rhotor' : numpy.float32(rhot),\ 'fpf' : numpy.float32(fpf),\ 'ftf': numpy.float32(ftf)} else: return {'error' : numpy.int_(error),\ 'time' : numpy.float32(t),\ 'rhotor' : numpy.array(rhot, dtype=float),\ 'fpf' : numpy.array(fpf, dtype=float),\ 'ftf': numpy.array(ftf, dtype=float)}
def create_BP_mask(dataset, num_MP, feat_dim): ''' Input: list of 2D array of size timesteps x input_dim Output: list of 2D array of size timesteps x output_dim, which only takes entry from part_index. For each frame t, [..., x(t-sampling_rate), x(t), x(t+sampling_rate),...], which contains window_size frames, is computed as output for frame t. ''' file_info = os.path.expanduser("~/work/Data/{}/{}_info.mat".format(dataset,dataset)) contents = sio.loadmat(file_info) BP_info = contents['config'][0] dim_per_frame=60 # 3(xyz) * 20joints if dataset=='MHAD': dim_per_frame=105 # 3(xyz) * 35 joints elif dataset =="HDM05": dim_per_frame =93 elif dataset =="CAD120": dim_per_frame=45 n_frame = feat_dim/dim_per_frame mask_all = [] for part_index in BP_info: part_index = np.int_(part_index[0]) entry_index = np.concatenate([(part_index-1)*3, (part_index-1)*3+1, (part_index-1)*3+2]) entry_index = np.sort(entry_index) entry_index_all=[] for i in range(n_frame): entry_index_all = np.append(entry_index_all, [entry_index+dim_per_frame*i]) entry_index_all=np.int_(np.array(entry_index_all)) mask = np.zeros((feat_dim,num_MP),dtype='float32') mask[entry_index_all,:]=1.0 mask_all.append(mask) mask_all = np.concatenate(mask_all, axis=1) return mask_all
def draw_hough_line(image, dist, theta, color=0): """ Draws a line described by the hough transform to an image :param image: Image to draw on :param dist: Hough transform distance :param theta: Hough transform angle :param color: intensity to draw line """ rows, cols = image.shape if abs(theta) < pi/4: # Find the x (col) intercepts x0 = int_(dist/cos(theta)) x1 = int_(x0 - rows * sin(theta)) intercepts = (0, x0, rows, x1) else: # Find the y (row) intercepts y0 = int_(dist/sin(theta)) y1 = int_(y0 + cols * cos(theta)) intercepts = (y0, 0, y1, cols) r, c = line(*intercepts) # Check to make sure each point stays in the image bounds and draw it for n in range(r.size): if r[n] >= 0 and c[n] >= 0: if r[n] < rows and c[n] < cols: image[r[n], c[n]] = color
def gradients_X(self, dL_dK, X, X2=None): #index = np.asarray(X, dtype=np.int) #index = index.reshape(index.size,) if hasattr(X, 'values'): X = X.values index = np.int_(X[:, 1]) index = index.reshape(index.size,) X_flag = index[0] >= self.output_dim #If input_dim == 1, use this #gX = np.zeros((X.shape[0], 1)) #Cheat to allow gradient for input_dim==2 gX = np.zeros(X.shape) if X2 is None: #Kuu or Kmm if X_flag: index -= self.output_dim gX[:, 0] = 2.*(dL_dK*self._gkuu_X(X, index)).sum(0) return gX else: raise NotImplementedError else: #Kuf or Kmn #index2 = np.asarray(X2, dtype=np.int) #index2 = index2.reshape(index2.size,) if hasattr(X2, 'values'): X2 = X2.values index2 = np.int_(X2[:, 1]) index2 = index2.reshape(index2.size,) X2_flag = index2[0] >= self.output_dim if X_flag and not X2_flag: #gradient of Kuf(Z, X) wrt Z index -= self.output_dim gX[:, 0] = (dL_dK*self._gkfu_z(X2, index2, X, index).T).sum(1) return gX else: raise NotImplementedError
def EField(X,Q,gamma,nxyz): N=X.shape[0]; X[:,2]=X[:,2]*gamma XX=np.max(X,axis=0)-np.min(X,axis=0) XX=XX*np.random.uniform(low=1.0,high=1.1) print 'mesh steps:', XX steps=XX/(nxyz-3) X=X/steps X_min=np.min(X,axis=0) X_mid=np.dot(Q,X)/np.sum(Q); X_off=np.floor(X_min-X_mid)+X_mid; X=X-X_off nx=nxyz[0];ny=nxyz[1];nz=nxyz[2];nzny=nz*ny Xi=np.int_(np.floor(X)+1) inds=np.int_(Xi[:,0]*nzny+Xi[:,1]*nz+Xi[:,2]) # 3d -> 1d print inds.shape, nxyz q=np.bincount(inds,Q,nzny*nx).reshape(nxyz) p=Phi(q,steps) Ex=np.zeros(p.shape);Ey=np.zeros(p.shape);Ez=np.zeros(p.shape); Ex[:nx-1,:,:]=(p[:nx-1,:,:]-p[1:nx,:,:])/steps[0] Ey[:,:ny-1,:]=(p[:,:ny-1,:]-p[:,1:ny,:])/steps[1] Ez[:,:,:nz-1]=(p[:,:,:nz-1]-p[:,:,1:nz])/steps[2] Exyz=np.zeros((N,3)) Exyz[:,0]=ndimage.map_coordinates(Ex,np.c_[X[:,0],X[:,1]+0.5,X[:,2]+0.5].T,order=1)*gamma Exyz[:,1]=ndimage.map_coordinates(Ey,np.c_[X[:,0]+0.5,X[:,1],X[:,2]+0.5].T,order=1)*gamma Exyz[:,2]=ndimage.map_coordinates(Ez,np.c_[X[:,0]+0.5,X[:,1]+0.5,X[:,2]].T,order=1) return Exyz
def EField(X,Q,gamma,kern,steps): N=X.shape[0]; X[:,2]=X[:,2]*gamma X=X/steps X_min=np.min(X,axis=0) X_mid=np.dot(Q,X)/np.sum(Q); X_off=np.floor(X_min-X_mid)+X_mid; X=X-X_off nx,ny,nz=np.int_(3+np.floor(np.max(X,axis=0))) nzny=nz*ny Xi=np.int_(np.floor(X)+1) inds=np.int_(Xi[:,0]*nzny+Xi[:,1]*nz+Xi[:,2]) # 3d -> 1d q=np.bincount(inds,Q,nzny*nx) print len(q), nx*ny*nz q=q.reshape(nx,ny,nz) #t0=time.time() print q.shape, steps p,kern=Phi(q,kern,steps) #t1=time.time(); print t1-t0 Ex=np.zeros(p.shape);Ey=np.zeros(p.shape);Ez=np.zeros(p.shape); Ex[:nx-1,:,:]=(p[:nx-1,:,:]-p[1:nx,:,:])/steps[0] Ey[:,:ny-1,:]=(p[:,:ny-1,:]-p[:,1:ny,:])/steps[1] Ez[:,:,:nz-1]=(p[:,:,:nz-1]-p[:,:,1:nz])/steps[2] Exyz=np.zeros((N,3)) Exyz[:,0]=ndimage.map_coordinates(Ex,np.c_[X[:,0],X[:,1]+0.5,X[:,2]+0.5].T,order=1)*gamma Exyz[:,1]=ndimage.map_coordinates(Ey,np.c_[X[:,0]+0.5,X[:,1],X[:,2]+0.5].T,order=1)*gamma Exyz[:,2]=ndimage.map_coordinates(Ez,np.c_[X[:,0]+0.5,X[:,1]+0.5,X[:,2]].T,order=1) #t1=time.time(); print t1-t0 return Exyz
def _find_nearest_node_ndarray(rmg, coords, mode='raise'): """Find the node nearest to a point. Parameters ---------- rmg : RasterModelGrid A RasterModelGrid. coords : tuple of float Coordinates of test points as *x*, then *y*. mode : {'raise', 'wrap', 'clip'}, optional What to do with out-of-bounds indices (as with numpy.ravel_multi_index). Returns ------- ndarray Nodes that are closest to the points. Examples -------- >>> from landlab.grid.raster_funcs import _find_nearest_node_ndarray >>> from landlab import RasterModelGrid >>> import numpy as np >>> grid = RasterModelGrid((4, 5)) >>> _find_nearest_node_ndarray(grid, (.25, 1.25)) 5 >>> _find_nearest_node_ndarray(grid, (.75, 2.25)) 11 """ column_indices = np.int_( np.around((coords[0] - rmg.node_x[0]) / rmg.node_spacing)) row_indices = np.int_( np.around((coords[1] - rmg.node_y[0]) / rmg.node_spacing)) return rmg.grid_coords_to_node_id(row_indices, column_indices, mode=mode)
def azimToBeam(self, azim): ''' Get azimuth of given beam. Return a negative beam number (offset by one instead of zero) if the azimuth corresponds to the back lobe. Return np.nan if the azimuth is not covered by any beam. **Args**: * **azim** (float): beam azimuth [deg. East] **Returns**: * **beam** (int): beam number ''' import numpy as np # Assume the azimuth comes from the front lobe phi = np.radians(azim - self.boresite) delta = np.degrees(np.arctan2(np.sin(phi), np.cos(phi))) beam = np.round(delta / self.bmsep + (self.maxbeam - 1) / 2.) if beam < 0.0 or beam > self.maxbeam: # This azimuth lies outside the front lobe phi = np.radians(self.boresite - azim - 180.0) delta = np.degrees(np.arctan2(np.sin(phi), np.cos(phi))) beam = np.round(delta / self.bmsep + (self.maxbeam - 1) / 2.) # Seperate back lobe azimuths from azimuths outside of either # field-of-view if beam >= 0 and beam < self.maxbeam: beam = -np.int_(beam + 1) else: beam = np.nan else: beam = np.int_(beam) return beam
def check_numpy_scalar_argument_return_generic(self): f = PyCFunction('foo') f += Variable('a1', numpy.int_, 'in, out') f += Variable('a2', numpy.float_, 'in, out') f += Variable('a3', numpy.complex_, 'in, out') foo = f.build() args = 2, 1.2, 1+2j results = numpy.int_(2), numpy.float_(1.2), numpy.complex(1+2j) assert_equal(foo(*args),results) args = [2], [1.2], [1+2j] assert_equal(foo(*args),results) args = [2], [1.2], [1,2] assert_equal(foo(*args),results) f = PyCFunction('foo') f += Variable('a1', 'npy_int', 'in, out') f += Variable('a2', 'npy_float', 'in, out') f += Variable('a3', 'npy_complex', 'in, out') foo = f.build() args = 2, 1.2, 1+2j results = numpy.int_(2), numpy.float_(1.2), numpy.complex(1+2j) assert_equal(foo(*args),results) args = [2], [1.2], [1+2j] assert_equal(foo(*args),results) args = [2], [1.2], [1,2] assert_equal(foo(*args),results)
def totalPower(latitude, timeTuple): global shell_normal global shell_faceO global shell_vertO matrixImport() month = timeTuple[1] day = timeTuple[2] hour = timeTuple[3] heading = 85 # Moving SSE shell_heading = heading shell_azimuths = 180/math.pi*numpy.arctan2(-shell_normal[:,1] ,shell_normal[:,0]) + heading shell_tilts = 90 - 180/math.pi*numpy.arcsin(shell_normal[:,2]) a = shell_vertO[numpy.int_(shell_faceO[:,0]),:] b = shell_vertO[numpy.int_(shell_faceO[:,1]),:] c = shell_vertO[numpy.int_(shell_faceO[:,2]),:] v1 = b - a v2 = c - a temp = numpy.cross(v1,v2)**2 temp = numpy.sum(temp, 1) shell_Area = 0.5*temp**0.5 #shell_area = numpy.sum(shell_Area) shell_flux = incident_radiation(month, day, hour, shell_tilts, shell_azimuths, latitude) shell_power = numpy.dot(shell_flux,shell_Area) #shell_fluxavg = shell_power/shell_area #return shell_fluxavg return shell_power
def get_pic(filename): """ Open image file and convert to numpy array. Array is 3D containing [r,g,b] at each [x,y] coordinate. """ return int_(asarray(Image.open(filename,'r')))
def pipeline(img, s_thresh=(190, 245), sx_thresh=(50, 170)): global brute_force global left_fit_hist global right_fit_hist # un distort the image img_undist = cv2.undistort(img, mtx, dist, None, mtx) # perspective transform the image img_warped = cv2.warpPerspective(img_undist, M, img_size, flags=cv2.INTER_LINEAR) # Convert to HLS color space and separate the V channel hls = cv2.cvtColor(img_warped, cv2.COLOR_BGR2HLS) l_channel = hls[:, :, 1] s_channel = hls[:, :, 2] # Sobel x sobelx = cv2.Sobel(l_channel, cv2.CV_64F, 1, 0) # Take the derivative in x abs_sobelx = np.absolute( sobelx ) # Absolute x derivative to accentuate lines away from horizontal scaled_sobel = np.uint8(255 * abs_sobelx / np.max(abs_sobelx)) # Threshold x gradient sxbinary = np.zeros_like(scaled_sobel) sxbinary[(scaled_sobel >= sx_thresh[0]) & (scaled_sobel <= sx_thresh[1])] = 1 # Threshold color channel s_binary = np.zeros_like(s_channel) s_binary[(s_channel >= s_thresh[0]) & (s_channel <= s_thresh[1])] = 1 # Stack each channel color_binary = np.dstack( (np.zeros_like(sxbinary), sxbinary, s_binary)) * 255 #cv2.imwrite('color_binary.jpg',color_binary) # Detect lane lines using sliding window leftx, lefty, rightx, righty, out_img1 = find_lane_pixels( color_binary, brute_force) ######### Polynomial fit # Fit a second order polynomial to each using `np.polyfit` left_fit = np.polyfit(lefty, leftx, 2) right_fit = np.polyfit(righty, rightx, 2) ###### Using a forgetting factor to average over old lane line fits: ff = 0.7 #Forgetting factor # Generate x and y values for plotting ploty = np.linspace(0, color_binary.shape[0] - 1, color_binary.shape[0]) try: # Check if left and right fit are none or incorrect left_fitx = left_fit[0] * ploty**2 + left_fit[1] * ploty + left_fit[2] right_fitx = right_fit[0] * ploty**2 + right_fit[ 1] * ploty + right_fit[2] # If left and right fit have worked, then set brute_force flag to false brute_force = False except TypeError: # Avoids an error if `left` and `right_fit` are still none or incorrect print('The function failed to fit a line!') # if lane lines weren't detected, set the lane lines to historic fit data for smooth results left_fitx = left_fit_hist[0] * ploty**2 + left_fit_hist[ 1] * ploty + left_fit_hist[2] right_fitx = right_fit_hist[0] * ploty**2 + right_fit_hist[ 1] * ploty + right_fit_hist[2] # set brute force flag to true for next lane line detection brute_force = True #### Sanity check if new lines found can be tursted. if brute_force == False: #new line has been found, lets check for validity of new line found #check if lines are parallel by comparing the diff between the constant term if (right_fit[2] - left_fit[2]) < 550 or ( right_fit[2] - left_fit[2]) > 850: #Not parallel left_fitx = left_fit_hist[0] * ploty**2 + left_fit_hist[ 1] * ploty + left_fit_hist[2] right_fitx = right_fit_hist[0] * ploty**2 + right_fit_hist[ 1] * ploty + right_fit_hist[2] brute_force = True else: #Lane line fit are parallel # Average the left and right fit using weighted avg with historic line data to smooth results if left_fit_hist.all() != 0 and right_fit_hist.all() != 0: left_fit = (left_fit + left_fit_hist * ff) / (1 + ff) right_fit = (right_fit + right_fit_hist * ff) / (1 + ff) left_fit_hist = left_fit right_fit_hist = right_fit #Calcualte the smoothed left_fitx and right fitx left_fitx = left_fit[0] * ploty**2 + left_fit[ 1] * ploty + left_fit[2] right_fitx = right_fit[0] * ploty**2 + right_fit[ 1] * ploty + right_fit[2] # Calculate radius of curvature left_curverad = curvature(left_fitx, ploty) right_curverad = curvature(right_fitx, ploty) curverad = (left_curverad + right_curverad) / 2 #Calculate lane position xm_per_pix = 3.7 / 370 # m per pixel in the x direction lane_pos = ((right_fitx[-1] + left_fitx[-1]) / 2 - color_binary.shape[1] / 2) * xm_per_pix # Create an image to draw the lines on color_warp = np.zeros_like(color_binary).astype(np.uint8) #color_warp = np.dstack((warp_zero, warp_zero, warp_zero)) # Recast the x and y points into usable format for cv2.fillPoly() pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))]) pts_right = np.array( [np.flipud(np.transpose(np.vstack([right_fitx, ploty])))]) pts = np.hstack((pts_left, pts_right)) # Draw the lane onto the warped blank image cv2.fillPoly(color_warp, np.int_([pts]), (0, 255, 0)) # Warp the blank back to original image space using inverse perspective matrix (Minv) newwarp = cv2.warpPerspective(color_warp, Minv, (img.shape[1], img.shape[0])) # Combine the result with the original image result = cv2.addWeighted(img, 1, newwarp, 0.3, 0) cv2.putText(result, 'Radius of Curvature: {:.0f} m'.format(curverad), (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2) cv2.putText(result, 'Lane Position- off center: {:.2f} m'.format(lane_pos), (50, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2) #plt.imshow(result) return result
def asr_calibrate(X, sfreq, cutoff=5, blocksize=10, win_len=0.5, win_overlap=0.66, max_dropout_fraction=0.1, min_clean_fraction=0.25, method='euclid'): """Calibration function for the Artifact Subspace Reconstruction method. The input to this data is a multi-channel time series of calibration data. In typical uses the calibration data is clean resting EEG data of ca. 1 minute duration (can also be longer). One can also use on-task data if the fraction of artifact content is below the breakdown point of the robust statistics used for estimation (50% theoretical, ~30% practical). If the data has a proportion of more than 30-50% artifacts then bad time windows should be removed beforehand. This data is used to estimate the thresholds that are used by the ASR processing function to identify and remove artifact components. The calibration data must have been recorded for the same cap design from which data for cleanup will be recorded, and ideally should be from the same session and same subject, but it is possible to reuse the calibration data from a previous session and montage to the extent that the cap is placed in the same location (where loss in accuracy is more or less proportional to the mismatch in cap placement). The calibration data should have been high-pass filtered (for example at 0.5Hz or 1Hz using a Butterworth IIR filter). Parameters ---------- X : array, shape=([n_trials, ]n_channels, n_samples) *zero-mean* (e.g., high-pass filtered) and reasonably clean EEG of not much less than 30 seconds (this method is typically used with 1 minute or more). sfreq : float Sampling rate of the data, in Hz. The following are optional parameters (the key parameter of the method is the ``cutoff``): cutoff: float Standard deviation cutoff for rejection. X portions whose variance is larger than this threshold relative to the calibration data are considered missing data and will be removed. The most aggressive value that can be used without losing too much EEG is 2.5. A quite conservative value would be 5 (default=5). blocksize : int Block size for calculating the robust data covariance and thresholds, in samples; allows to reduce the memory and time requirements of the robust estimators by this factor (down to Channels x Channels x Samples x 16 / Blocksize bytes) (default=10). win_len : float Window length that is used to check the data for artifact content. This is ideally as long as the expected time scale of the artifacts but short enough to allow for several 1000 windows to compute statistics over (default=0.5). win_overlap : float Window overlap fraction. The fraction of two successive windows that overlaps. Higher overlap ensures that fewer artifact portions are going to be missed, but is slower (default=0.66). max_dropout_fraction : float Maximum fraction of windows that can be subject to signal dropouts (e.g., sensor unplugged), used for threshold estimation (default=0.1). min_clean_fraction : float Minimum fraction of windows that need to be clean, used for threshold estimation (default=0.25). method : {'euclid', 'riemann'} Metric to compute the covariance matric average. Returns ------- M : array Mixing matrix. T : array Threshold matrix. """ logging.debug('[ASR] Calibrating...') [nc, ns] = X.shape # window length for calculating thresholds N = int(np.round(win_len * sfreq)) if method == 'euclid': U = np.zeros((blocksize, nc, nc)) for k in range(blocksize): rangevect = np.minimum(ns - 1, np.arange(k, ns + k, blocksize)) x = X[:, rangevect] U[k, ...] = x @ x.T Uavg = block_geometric_median(U.reshape((-1, nc * nc)) / blocksize, 2) Uavg = Uavg.reshape((nc, nc)) elif method == 'riemann': blocksize = int(ns // blocksize) U = block_covariance(X, window=blocksize, overlap=win_overlap) Uavg = pyriemann.utils.mean.mean_covariance(U, metric='riemann') # get the mixing matrix M M = linalg.sqrtm(np.real(Uavg)) D, Vtmp = linalg.eig(M) # D, Vtmp = nonlinear_eigenspace(M, nc) V = Vtmp[:, np.argsort(D)] # get the threshold matrix T x = np.abs(np.dot(V, X)) offsets = np.int_(np.arange(0, ns - N, np.round(N * (1 - win_overlap)))) mu = np.zeros(nc) sig = np.zeros(nc) for ichan in range(nc): rms = x[ichan, :]**2 Y = [] for o in offsets: Y.append(np.sqrt(np.sum(rms[o:o + N]) / N)) mu[ichan], sig[ichan], alpha, beta = fit_eeg_distribution( Y, min_clean_fraction, max_dropout_fraction) T = np.dot(np.diag(mu + cutoff * sig), V.T) logging.debug('[ASR] Calibration done.') return M, T
def age_consistency(data): """ Construct age_head from agerange if available; otherwise use CPS value. Construct age_spouse as a normally-distributed agediff from age_head. """ # set random-number-generator seed so that always get same random numbers np.random.seed(seed=123456789) # generate random integers to smooth age distribution in agerange shape = data['age_head'].shape agefuzz8 = np.random.randint(0, 9, size=shape) agefuzz9 = np.random.randint(0, 10, size=shape) agefuzz10 = np.random.randint(0, 11, size=shape) agefuzz15 = np.random.randint(0, 16, size=shape) # assign age_head using agerange midpoint or CPS age if agerange absent data['age_head'] = np.where(data['agerange'] == 0, data['age_head'], (data['agerange'] + 1 - data['dsi']) * 10) # smooth the agerange-based age_head within each agerange data['age_head'] = np.where( np.logical_and(data['agerange'] == 1, data['dsi'] == 0), data['age_head'] - 3 + agefuzz9, data['age_head']) data['age_head'] = np.where( np.logical_and(data['agerange'] == 2, data['dsi'] == 0), data['age_head'] - 4 + agefuzz9, data['age_head']) data['age_head'] = np.where( np.logical_and(data['agerange'] == 3, data['dsi'] == 0), data['age_head'] - 5 + agefuzz10, data['age_head']) data['age_head'] = np.where( np.logical_and(data['agerange'] == 4, data['dsi'] == 0), data['age_head'] - 5 + agefuzz10, data['age_head']) data['age_head'] = np.where( np.logical_and(data['agerange'] == 5, data['dsi'] == 0), data['age_head'] - 5 + agefuzz10, data['age_head']) data['age_head'] = np.where( np.logical_and(data['agerange'] == 6, data['dsi'] == 0), data['age_head'] - 5 + agefuzz15, data['age_head']) data['age_head'] = np.where( np.logical_and(data['agerange'] == 1, data['dsi'] == 1), data['age_head'] - 0 + agefuzz8, data['age_head']) data['age_head'] = np.where( np.logical_and(data['agerange'] == 2, data['dsi'] == 1), data['age_head'] - 2 + agefuzz8, data['age_head']) data['age_head'] = np.where( np.logical_and(data['agerange'] == 3, data['dsi'] == 1), data['age_head'] - 4 + agefuzz10, data['age_head']) # convert zero age_head to one data['age_head'] = np.where(data['age_head'] == 0, 1, data['age_head']) # assign age_spouse relative to age_head if married; # if head is not married, set age_spouse to zero; # if head is married but has unknown age, set age_spouse to one; # do not specify age_spouse values below 15 adiff = np.random.normal(0.0, 4.0, size=shape) agediff = np.int_(adiff.round()) age_sp = data['age_head'] + agediff age_spouse = np.where(age_sp < 15, 15, age_sp) data['age_spouse'] = np.where( data['mars'] == 2, np.where(data['age_head'] == 1, 1, age_spouse), 0) return data
def calculate_mean_face(database): # Calculating mean of all faces return np.int_(database.mean(0))
def main(argv): # print ('Number of arguments:', len(argv), 'arguments.') # print ('Argument List:', str(argv)) contours_dir = "./data/panel/" rooftop_img_dir = "./panel/" rooftop_csv_path = './data/rooftop_solar_array_outlines_new.csv' rooftop_iou_csv_path = './rooftop_iou.csv' with open(rooftop_iou_csv_path, 'a') as csvfile: myFields = [ 'id', 'location_id', 'label', 'solar_list', 'contour_num', 'iou' ] writer = csv.DictWriter(csvfile, fieldnames=myFields) writer.writeheader() with open(rooftop_csv_path, newline='') as rooftop_csv_file: reader = csv.DictReader(rooftop_csv_file) for row in reader: roof = {} roof = row contour_mask = eval(row['contour_num']) # print(contour_mask) contour_img = np.zeros((800, 800, 3), np.uint8) for contour in contour_mask: contour_path = contours_dir + contour + '.png' # print(contour_path ) img = cv2.imread(contour_path) # cv2.imshow('img', img) # cv2.waitKey(0) excluded_color = [0, 0, 0] indices_list = np.where(np.all(img != excluded_color, axis=-1)) contour_img[indices_list] = [255, 255, 255] # cv2.imshow('img',contour_img) # cv2.waitKey(0) solar_mask = np.zeros((800, 800, 3), np.uint8) outline_list = eval(row['solar_list']) for outline in outline_list: # print(outline) pts = np.asarray(outline) cv2.fillPoly(solar_mask, np.int_([pts]), (255, 255, 255)) # cv2.polylines(solar_mask, [pts], True, (0, 0, 255), 2) # cv2.imshow('img', solar_mask) # cv2.waitKey(0) # cv2.fillPoly(img_to_show, np.int_([pts]), (198, 133, 61)) # cv2.fillPoly(img_to_show, np.int_([pts]), (255, 255, 255)) # predict_gray_mask = cv2.cvtColor(contour_img, cv2.COLOR_BGR2GRAY) label_gray_mask = cv2.cvtColor(solar_mask, cv2.COLOR_BGR2GRAY) # # # rooftop_mask_size = cv2.countNonZero(rooftop_gray_mask) # # solar_mask_size = cv2.countNonZero(solar_gray_mask) # # size_ration = solar_mask_size / rooftop_mask_size # # print(rooftop_mask_size) # # print(solar_mask_size) # # print(size_ration) # # # IOU Score intersection = np.logical_and(predict_gray_mask, label_gray_mask) union = np.logical_or(predict_gray_mask, label_gray_mask) iou_score = np.sum(intersection) / np.sum(union) # print(iou_score) # # print(iou_score) # # # print(size_ration/iou_score) # cv2.imshow(row['id'], img_to_show) # hotkey() roof['iou'] = iou_score with open(rooftop_iou_csv_path, 'a') as csvfile_new: writer = csv.writer(csvfile_new) writer.writerow([ roof['id'], roof['location_id'], roof['label'], roof['solar_list'], roof['contour_num'], roof['iou'] ]) csvfile_new.close() rooftop_csv_file.close()
def calculate_precip_timeseries(avg_interval, precip_varname, season, file_time_resolution, precip_data_input_directory): ''' This function takes raw AOSMET precip data from GoAmazon site. It currently calculates an average according to avg_interval. The extract dates from filename section will need to be ammended based on the raw data files being extracted. Need to find a way to automate this more seamlessly among different ARM sites/datasets ''' # timesteps_in_day timesteps_in_day = (1. / avg_interval) * 24 #Load each individual file f = sorted(glob(precip_data_input_directory + '*.cdf')) # Get file list length_fnames = len(f) # Create date file from filenames dts = [] # Create an empty list to hold dates dts_yymmdd = [] # Extract datetimes from the filenames for i in f: if i[-10:-4] == 'custom': dts.append(dt.datetime.strptime( i[-26:-11], '%Y%m%d.%H%M%S')) # Extract dates from filename dts_yymmdd.append(dt.datetime.strptime( i[-26:-18], '%Y%m%d')) # Extract dates from filename in yymmdd format else: dts.append(dt.datetime.strptime( i[-19:-4], '%Y%m%d.%H%M%S')) # Extract dates from filename dts_yymmdd.append(dt.datetime.strptime( i[-19:-11], '%Y%m%d')) # Extract dates from filename in yymmdd format # Ensure that there no multiple files on the same day for i, j in enumerate(dts_yymmdd[:-1]): td = dts_yymmdd[i + 1] - dts_yymmdd[i] if td == 0: print(dts[i]) print( 'There are multiple files for the above date. Need to delete or combine files.' ) return # Get start and end dates strt_date = dts_yymmdd[0] temp_date = strt_date end_date = dts_yymmdd[-1] # Find missing days. This includes days from the beginning of the year (if the series does not start at Jan 1st) # and days at the end of the year (if the series does not end on Dec. 31st) missing_dates = [] # Storing missing dates in this list continuous_dates = [ ] # Storing continuous dates in this list (dates available + missing dates) ctr = 0 # counter for debugging reasons # Fill in days beginning at Jan 1st to the start date if (temp_date.month, temp_date.day) != (1, 1): pretemp_date = dt.datetime(temp_date.year, 1, 1, 0, 0) while pretemp_date < temp_date: continuous_dates.append(pretemp_date) if (pretemp_date not in dts_yymmdd): missing_dates.append(pretemp_date) pretemp_date += dt.timedelta(days=1) ctr += 1 # Make continuous dates and find missing dates from what is included in the files while temp_date <= end_date: continuous_dates.append(temp_date) if (temp_date not in dts_yymmdd): missing_dates.append(temp_date) temp_date += dt.timedelta(days=1) ctr += 1 # Fill in days from end date to Dec 31st if (end_date.month, end_date.day) != (12, 31): post_end_date = dt.datetime(end_date.year, 12, 31, 0, 0) end_temp_date = end_date while end_temp_date < post_end_date: continuous_dates.append(end_temp_date) missing_dates.append(end_temp_date) end_temp_date += dt.timedelta(days=1) ctr += 1 # file_time_resolution is inluced to indicate whether the .cdf file is for daily data or for an enitre year # we define a time factor here to help construct the timeseries if file_time_resolution == 'daily': time_factor = 1 daily = True else: time_factor = 366 # 366 in case of leap yr daily = False # create array, H, that is either of the form (day, timestep) or (year, timestep), in the latter case # the array will be much longer H = np.zeros((int(len(f)), int(timesteps_in_day) * time_factor)) - 1 # now loop through and average data between points in the days. Ex: if you choose 3 hr avg interval, # we look for data points between time bounds evenly spaced by 3 hr, starting at 00 hr, so points # between 0 and 3 hrs will be averaged as will 3 to 6 hrs, etc. for a, i in enumerate(f): f1 = Dataset(i, 'r') # read in data if daily == False: tot_seconds = f1.variables['time'][-1] time_factor = np.ceil( tot_seconds / 60 / 60 / 24) # this will return eith either 365 or 366 precip = f1.variables[precip_varname][:] # precipitation in mm hr-1 time = f1.variables[ 'time_offset'][:] # seconds since yy-mm-dd 00:00:00 0:00 step = 86400. / timesteps_in_day array_loop = np.arange(step, 86400 * time_factor + step, step) # now loop through and average data between points in the days. Ex: if you choose 3 hr avg interval, # we look for data points between time bounds evenly spaced by 3 hr, starting at 00 hr, so points # between 0 and 3 hrs will be averaged as will 3 to 6 hrs, etc. for j, k in enumerate(array_loop): if k == step: ind = np.where(time < k + 1) elif (k > step): ind = np.where( np.logical_and(time > k + 1 - step, time < k + 1)) ############ QUALITY CONTROL SHOULD BE PLACED HERE ################ precip = np.array(precip) Q2 = precip[ ind] # find data points between the timestpes to average Q2[np.logical_or(Q2 < 0, Q2 > 100)] = np.nan H[a, j] = np.nanmean(Q2) # store average value in the array #if season == 'annual': if (daily == True): Hnew = np.zeros( (int(len(continuous_dates)), int(timesteps_in_day) * time_factor)) # Create new array to fill in missing dates Hnew[:] = np.nan # Initialize to nan #Fill in missing days with NaN by defining new array Hnew (Hnew = H + missing days) if len(missing_dates) > 0: for i, j in enumerate( continuous_dates): # loop through continuous dates if j in dts_yymmdd: ind = np.int_([ a for a, b in enumerate(dts_yymmdd) if b == j ])[0] # find index of where j is in dts_yymmdd Hnew[i, :] = H[ind, :] else: Hnew[i, :] = np.nan elif len(missing_dates) == 0: Hnew = np.copy(H) precip_timeseries = Hnew.flatten() else: precip_timeseries = [] # store precip in here for i in np.arange(H.shape[0]): if np.sum(H[i, -int(timesteps_in_day):]) < 0: # we initialized H # to have values of -1, if those values are still -1, then #the yr is not a leap year, so we store the first 365*steps_in_day points precip_timeseries = np.append(precip_timeseries, H[i, :-int(timesteps_in_day)]) else: # else this is a leap year and we store all points precip_timeseries = np.append(precip_timeseries, H[i, :]) # else: # if (daily==True): # # season_ind=np.zeros(H.shape[0],dtype='bool') # logical array for season indices # # define seasons # if season == 'DJF': # season_month = [12,1,2] # elif season == 'MAM': # season_month = [3,4,5] # elif season == 'JJA': # season_month = [6,7,8] # elif season == 'SON': # season_month = [9,10,11] # # # # loop through the dts_yymmdd and if the date is within the selected season, the logical array value for that index becomes true # for i in np.arange(len(dts_yymmdd)): # if dts_yymmdd[i].month in season_month: # season_ind[i] = True # # H[season_ind==False,:] =np.nan # change the matrix to nan where the values are not within the season # # loop through as before # # # # Hnew=np.zeros((int(len(f)+len(missing_dates)),int(timesteps_in_day)*time_factor)) # Create new array to fill in missing dates # Hnew[:]=np.nan # Initialize to nan # # # #Fill in missing days with NaN by defining new array Hnew (Hnew = H + missing days) # if len(missing_dates)>0: # for i,j in enumerate(continuous_dates): # # if j in dts_yymmdd: # ind=np.int_([a for a,b in enumerate(dts_yymmdd) if b == j])[0] # Hnew[i,:]=H[ind,:] # else: # Hnew[i,:]=np.nan # # elif len(missing_dates)==0: # Hnew=np.copy(H) # # #Reshape Hnew into timeseries with length = timesteps_in_day*(length_fnames+length(missing_days) # # # precip_timeseries=Hnew.flatten() # # else: # #seasonal filter in days # if season == 'DJF': # strt_ind = 0 # end_ind = 31+31+28-1 # elif season == 'MAM': # strt_ind = 31+31+28-1 # end_ind = strt_ind + 31+30+31 # elif season == 'JJA': # strt_ind = 31+31+28+31+30+31-1 # end_ind = strt_ind + 30+31+31 # elif season == 'SON': # strt_ind = 31+31+28+31+30+31+30+31+31-1 # end_ind = strt_ind + 30+31+30 # # strt_ind =int(timesteps_in_day*strt_ind) # end_ind =int(timesteps_in_day*end_ind) # # # #seasonal filter, since rows of H are years, we use the indices above to filter each column, then store it # # precip_timeseries = [] # for i in np.arange(H.shape[0]): # if np.sum(H[i,-int(timesteps_in_day):])<0: # if season == 'DJF': # x = np.zeros(366*int(timesteps_in_day),dtype='bool') # x[strt_ind:end_ind+1] = True # H[i,x==False] = np.nan # precip_timeseries = np.append(precip_timeseries,H[i,:]) # else: # x = np.zeros(366*int(timesteps_in_day),dtype='bool') # x[strt_ind+1:end_ind] = True # H[i,x==False] = np.nan # precip_timeseries = np.append(precip_timeseries,H[i,:]) # # else: # x = np.zeros(366*int(timesteps_in_day),dtype='bool') # x[strt_ind:end_ind] = True # H[i,x==False] = np.nan # precip_timeseries = np.append(precip_timeseries,H[i,:-int(timesteps_in_day)]) # create time bounds date_list = [ continuous_dates[0] + dt.timedelta(hours=x) for x in np.arange( 0, timesteps_in_day * len(continuous_dates) * avg_interval, avg_interval) ] time_uppr_bnd = np.roll(date_list, -1) time_uppr_bnd[-1] = time_uppr_bnd[-2] + dt.timedelta(seconds=step) time_bnds = np.stack((np.asarray(time_uppr_bnd), np.asarray(date_list))) if season != 'annual': season_ind = np.zeros(precip_timeseries.shape[0], dtype='bool') # logical array for season indices # define seasons if season == 'DJF': season_month = [12, 1, 2] elif season == 'MAM': season_month = [3, 4, 5] elif season == 'JJA': season_month = [6, 7, 8] elif season == 'SON': season_month = [9, 10, 11] # loop through the dts_yymmdd and if the date is within the selected season, the logical array value for that index becomes true for i in np.arange(len(date_list)): if date_list[i].month in season_month: season_ind[i] = True precip_timeseries[season_ind == False] = np.nan return precip_timeseries, time_bnds
def calculate_MWR_interp(avg_interval, cwv_varname_mwr, window_length, hours_minus_GMT, season, cwv_data_input_directory): ''' This function takes raw MWR column integrated water vapor (CWV) data. It calculates an average according to avg_interval and linearly interpolates over missing data periods less than those specified by window_length (hours) ''' # timesteps_in_day timesteps_in_day = (1. / avg_interval) * 24 # window_length is the length (in hours) of the window over which one # wishes to linearly interpolate the CWV data window = timesteps_in_day / (24. / window_length) #Load each individual file f = glob(cwv_data_input_directory + '*.cdf') # Get file list length_fnames = len(f) # Create date file from filenames dts = [] # Create an empty list to hold dates dts_yymmdd = [] # f=iter(f) # Make list iterable for i in f: if i[-10:-4] == 'custom': dts.append(dt.datetime.strptime( i[-26:-11], '%Y%m%d.%H%M%S')) # Extract dates from filename dts_yymmdd.append(dt.datetime.strptime( i[-26:-18], '%Y%m%d')) # Extract dates from filename in yymmdd format else: dts.append(dt.datetime.strptime( i[-19:-4], '%Y%m%d.%H%M%S')) # Extract dates from filename dts_yymmdd.append(dt.datetime.strptime( i[-19:-11], '%Y%m%d')) # Extract dates from filename in yymmdd format ## Ensure that there no multiple files on the same day for i, j in enumerate(dts_yymmdd[:-1]): td = dts_yymmdd[i + 1] - dts_yymmdd[i] if td == 0: print(dts[i]) print( 'There are multiple files for the above date. Need to delete or combine files.' ) return # Get start and end dates strt_date = dts_yymmdd[0] temp_date = strt_date end_date = dts_yymmdd[-1] # Find missing days missing_dates = [] # Storing missing dates in this list continuous_dates = [] ctr = 0 while temp_date <= end_date: continuous_dates.append(temp_date) if (temp_date not in dts_yymmdd): missing_dates.append(temp_date) temp_date += dt.timedelta(days=1) ctr += 1 #Define days to ignore afternoon data due to problems around equinox #Ignore data in the 30 days surrounding equinox yy_strt = dts_yymmdd[0].timetuple().tm_year yy_end = dts_yymmdd[-1].timetuple().tm_year year_diff = yy_end - yy_strt equinox = [] while yy_strt <= yy_end: d01, d02 = dt.datetime(yy_strt, 3, 6), dt.datetime(yy_strt, 4, 4) # Spring equinox d11, d12 = dt.datetime(yy_strt, 9, 6), dt.datetime(yy_strt, 10, 5) # Autumn equinox while d01 <= d02: equinox.append(d01) d01 += dt.timedelta(days=1) while d11 <= d12: equinox.append(d11) d11 += dt.timedelta(days=1) yy_strt += 1 H = np.zeros((int(len(f)), int(timesteps_in_day))) H[:] = np.nan # Initialize to nan #Read in time and cwv for a, i in enumerate(f): f1 = Dataset(i, 'r') cwv = f1.variables[cwv_varname_mwr][:] # column vapor in cm time = f1.variables[ 'time_offset'][:] # seconds since yy-mm-dd 00:00:00 0:00 TB23 = f1.variables['tbsky23'][:] # sky brightness temperature in K step = 86400. / timesteps_in_day array_loop = np.arange(step, 86400 + step, step) for j, k in enumerate(array_loop): if k == step: ind = np.where(time < k + 1) elif (k > step): ind = np.where( np.logical_and(time > k + 1 - step, time < k + 1)) Q = cwv[ind] TB23_Q = TB23[ind] #Ridding of erroneous data #Rids of -9999 (missing data) #Q[Q==-9999]=np.nan #Q[Q==0]=np.nan #Q[TB23_Q>100]=np.nan #Rids of erroneous data that occur surrounding solstices and #equinoxes from 11 am to 2 pm local time # If the day is within +/- 30 days of equinox if dts_yymmdd[a] in equinox: # Get local time dates_day = [ dts_yymmdd[a] + dt.timedelta(seconds=z) - dt.timedelta(hours=hours_minus_GMT) for z in time[ind] ] ind_eq = np.int_([ y for y, z in enumerate(dates_day) if (z.timetuple().tm_hour >= 11) & (z.timetuple().tm_hour <= 14) ]) Q[ind_eq] = np.nan #H[a,j]=np.nanmean(Q) if H[a, j] <= 0: H[a, j] = np.nan Hnew = np.zeros( (int(len(f) + len(missing_dates)), int(timesteps_in_day))) # Create new array to fill in missing dates Hnew[:] = np.nan # Initialize to nan #Fill in missing days with NaN by defining new array Hnew (Hnew = H + missing days) if len(missing_dates) > 0: for i, j in enumerate(continuous_dates): if j in dts_yymmdd: ind = np.int_([a for a, b in enumerate(dts_yymmdd) if b == j])[0] Hnew[i, :] = H[ind, :] else: Hnew[i, :] = np.nan elif len(missing_dates) == 0: Hnew = np.copy(H) #Reshape Hnew into timeseries with length = timesteps_in_day*(length_fnames+length(missing_days) cwv_timeseries_raw = Hnew.flatten() #Do linear interpolation over pre-defined window of NaN (defined in the #first part of the code) nan_idx = np.isnan(cwv_timeseries_raw) nan_ind = np.where(np.isnan(cwv_timeseries_raw))[0] # nan_window = [] # Get the lengths of NaN blocks. Ignore if length > specified window length for l, m in groupby(enumerate(nan_ind), lambda x: x[1] - x[0]): temp = (list(map(itemgetter(1), m))) if len(temp) <= window_length / avg_interval: nan_window += temp nan_window = (np.asarray(nan_window, dtype=int)) cwv_timeseries_interp = np.copy(cwv_timeseries_raw) indices = np.arange(0, cwv_timeseries_raw.size) not_nan = np.logical_not(np.isnan(cwv_timeseries_raw)) cwv_timeseries_interp[nan_window] = np.interp(indices[nan_window], indices[not_nan], cwv_timeseries_raw[not_nan]) return cwv_timeseries_interp
def calculate_MWRRET_interp(avg_interval, window_length, season, cwv_data_input_directory): ''' This function takes raw MWRRET column integrated water vapor (CWV) data. It calculates an average according to avg_interval and linearly interpolates over missing data periods less than those specified by window_length (hours) ''' # timesteps_in_day timesteps_in_day = (1. / avg_interval) * 24 # window_length is the length (in hours) of the window over which one # wishes to linearly interpolate the CWV data window = timesteps_in_day / (24. / window_length) #Load each individual file f = sorted(glob(cwv_data_input_directory + '*.cdf')) # Get file list length_fnames = len(f) # Create date file from filenames dts = [] # Create an empty list to hold dates dts_yymmdd = [] # Extract datetimes from the filenames for i in f: if i[-10:-4] == 'custom': dts.append(dt.datetime.strptime( i[-26:-11], '%Y%m%d.%H%M%S')) # Extract dates from filename dts_yymmdd.append(dt.datetime.strptime( i[-26:-18], '%Y%m%d')) # Extract dates from filename in yymmdd format else: dts.append(dt.datetime.strptime( i[-19:-4], '%Y%m%d.%H%M%S')) # Extract dates from filename dts_yymmdd.append(dt.datetime.strptime( i[-19:-11], '%Y%m%d')) # Extract dates from filename in yymmdd format # Ensure that there no multiple files on the same day for i, j in enumerate(dts_yymmdd[:-1]): td = dts_yymmdd[i + 1] - dts_yymmdd[i] if td == 0: print(dts[i]) print( 'There are multiple files for the above date. Need to delete or combine files.' ) return # Get start and end dates strt_date = dts_yymmdd[0] temp_date = strt_date end_date = dts_yymmdd[-1] # Find missing days. This includes days from the beginning of the year (if the series does not start at Jan 1st) # and days at the end of the year (if the series does not end on Dec. 31st) missing_dates = [] # Storing missing dates in this list continuous_dates = [ ] # Storing continuous dates in this list (dates available + missing dates) ctr = 0 # counter for debugging reasons # Fill in days beginning at Jan 1st to the start date if (temp_date.month, temp_date.day) != (1, 1): pretemp_date = dt.datetime(temp_date.year, 1, 1, 0, 0) while pretemp_date < temp_date: continuous_dates.append(pretemp_date) if (pretemp_date not in dts_yymmdd): missing_dates.append(pretemp_date) pretemp_date += dt.timedelta(days=1) ctr += 1 # Make continuous dates and find missing dates from what is included in the files while temp_date <= end_date: continuous_dates.append(temp_date) if (temp_date not in dts_yymmdd): missing_dates.append(temp_date) temp_date += dt.timedelta(days=1) ctr += 1 # Fill in days from end date to Dec 31st if (end_date.month, end_date.day) != (12, 31): post_end_date = dt.datetime(end_date.year, 12, 31, 0, 0) end_temp_date = end_date while end_temp_date < post_end_date: continuous_dates.append(end_temp_date) missing_dates.append(end_temp_date) end_temp_date += dt.timedelta(days=1) ctr += 1 # define some matrix H, which we will fill in with the cwv data H = np.zeros((int(len(f)), int(timesteps_in_day))) H[:] = np.nan # Initialize to nan #Read in time and cwv for a, i in enumerate(f): f1 = Dataset(i, 'r') # read in file data cwv = f1.variables['be_pwv'][:] # column vapor in cm time = f1.variables[ 'time_offset'][:] # seconds since yy-mm-dd 00:00:00 0:00 step = 86400. / timesteps_in_day # timestep array_loop = np.arange(step, 86400 + step, step) # the timestep intervals in the day # now loop through and average data between points in the days. Ex: if you choose 3 hr avg interval, # we look for data points between time bounds evenly spaced by 3 hr, starting at 00 hr, so points # between 0 and 3 hrs will be averaged as will 3 to 6 hrs, etc. for j, k in enumerate(array_loop): if k == step: ind = np.where(time < k + 1) elif (k > step): ind = np.where( np.logical_and(time > k + 1 - step, time < k + 1)) ############ QUALITY CONTROL SHOULD BE PLACED HERE ################ cwv = np.array(cwv) # cwv as array Q1 = cwv[ ind] # indices defined above, points between the timesteps Q1 = np.array(Q1) Q1[Q1 <= 0] = np.nan # no negative cwv, nan it H[a, j] = np.nanmean( Q1) # average the points together and store them in H Hnew = np.zeros( (int(len(f) + len(missing_dates)), int(timesteps_in_day))) # Create new array to fill in missing dates Hnew[:] = np.nan # Initialize to nan # if we filter by season if season != 'annual': season_ind = np.zeros(H.shape[0], dtype='bool') # logical array for season indices # define seasons if season == 'DJF': season_month = [12, 1, 2] elif season == 'MAM': season_month = [3, 4, 5] elif season == 'JJA': season_month = [6, 7, 8] elif season == 'SON': season_month = [9, 10, 11] # loop through the dts_yymmdd and if the date is within the selected season, the logical array value for that index becomes true for i in np.arange(len(dts_yymmdd)): if dts_yymmdd[i].month in season_month: season_ind[i] = True H[season_ind == False, :] = np.nan # change the matrix to nan where the values are not within the season # loop through as before if len(missing_dates) > 0: for i, j in enumerate( continuous_dates): # loop through continuous dates if j in dts_yymmdd: # if continuous date is in a data file: ind = np.int_([a for a, b in enumerate(dts_yymmdd) if b == j ])[0] # find index of where j is in dts_yymmdd Hnew[i, :] = H[ind, :] # fill in the new matrix with the value else: Hnew[ i, :] = np.nan # else the new matrix has a nan value where the continuous date does not exist in the files elif len(missing_dates) == 0: Hnew = np.copy(H) cwv_timeseries_raw = Hnew.flatten() #Do linear interpolation over pre-defined window of NaN (defined in the #first part of the code) nan_idx = np.isnan(cwv_timeseries_raw) nan_ind = np.where(np.isnan(cwv_timeseries_raw))[0] # nan_window = [] # Get the lengths of NaN blocks. Ignore if length > specified window length for l, m in groupby(enumerate(nan_ind), lambda x: x[1] - x[0]): temp = (list(map(itemgetter(1), m))) if len(temp) <= window_length / avg_interval: nan_window += temp nan_window = (np.asarray(nan_window, dtype=int)) cwv_timeseries_interp = np.copy(cwv_timeseries_raw) indices = np.arange(0, cwv_timeseries_raw.size) not_nan = np.logical_not(np.isnan(cwv_timeseries_raw)) cwv_timeseries_interp[nan_window] = np.interp(indices[nan_window], indices[not_nan], cwv_timeseries_raw[not_nan]) cwv_timeseries_interp = cwv_timeseries_interp * 10 # create time bnds date_list = [ continuous_dates[0] + dt.timedelta(hours=x) for x in np.arange( 0, timesteps_in_day * len(continuous_dates) * avg_interval, avg_interval) ] time_uppr_bnd = np.roll(date_list, -1) time_uppr_bnd[-1] = time_uppr_bnd[-2] + dt.timedelta(seconds=step) time_bnds = np.stack((np.asarray(time_uppr_bnd), np.asarray(date_list))) return cwv_timeseries_interp, time_bnds
#timepp=endepp-startpp timel=endel-startl #timecp=timet+timepp timetot=timet+timel print ('Time for the clustering process: %.2f s' %(timet)) # Determine number of clusters and clustersize Cs=np.zeros((2,N)) for a in range(0,N): Ca=Clust[a] if np.int_(np.shape(Ca)) > 1: Cs[0,a]=np.int_(np.shape(Ca)) Cs[1,a]=a (a1,Nc)=np.int_(np.shape(np.nonzero(Cs[0]))) Cmax=np.int_(np.max(Cs[0])) Ncl= np.count_nonzero(np.extract(Cs[0,:]>=Nl,Cs)) # Percentage of the largest cluster Pc=float(Cmax)/float(N) # Determine number of noise points Nn=float(N)-np.sum(Cs[0,:])
def gen_matrix(x,y): array=np.int_(np.random.rand(x,y)*10) print (array) return array
def upload_hasil(): if request.method == 'POST': a = request.files['file'] # variabel untuk nyimpan file ta = request.form['ta'] sem = request.form['semester'] a.save(os.path.join('app/upload_data', 'DATA.csv') ) # wadah untuk setiap kita nge-load, hasilnya disimpan disitu dataku = pd.read_csv('app/upload_data/DATA.csv') load_vectorizer = pickle.load(open("app/pickle_load/vectorizer.b", "rb"), encoding='latin1') load_naivebayes = pickle.load(open("app/pickle_load/nb.b", "rb"), encoding='latin1') pegawai = [str(x) for x in list(dataku["pegawai_id_pegawai"])] ampu = [str(x) for x in list(dataku["ampu_id_ampu"])] baku = [x for x in katabaku["kata_baku"]] new_data = [] save_index = [] def unique(listq): unique_list = [] for x in listq: unique_list.append(x) return unique_list listStemUji = [] for low in dataku.answer: lowerku = low.lower() textStemmed = stemmer.stem(lowerku) textClean = remover.remove(textStemmed) n = 0 for i in katabaku["vocabulary"]: if textClean == i: textClean = baku[n] n += 1 listStemUji.append(textClean) data_sentimen = [] tfidf = load_vectorizer.transform(listStemUji) for i in tfidf: sentiment = load_naivebayes.predict(i) data_sentimen.append(sentiment) data_sentimen for i in range(0, len(dataku.answer)): index = pegawai[i] + ',' + ampu[i] save_index.append(index) new_data.append([index, [data_sentimen[i]]]) new_data = unique(new_data) clean_index = list(set(save_index)) total = 0 y = 0 data_gue = [] sumPositive = 0 sumNegative = 0 sumNetral = 0 sumAll = 0 totalPrecentPositive = 0 totalPrecentNetral = 0 totalPrecentNegative = 0 for i in clean_index: for j in new_data: if str(i) == j[0]: if np.int_(j[1]) == 0: sumNegative += 1 elif np.int_(j[1]) == 2: sumPositive += 1 elif np.int_(j[1]) == 1: sumNetral += 1 sumAll += 1 precentNegative = round((float(sumNegative) / float(sumAll)) * 100, 2) precentPositive = round((float(sumPositive) / float(sumAll)) * 100, 2) precentNetral = round((float(sumNetral) / float(sumAll)) * 100, 2) totalPrecentPositive += precentPositive totalPrecentNetral += precentNetral totalPrecentNegative += precentNegative data_gue.append( [i, precentPositive, precentNetral, precentNegative]) rataPOS = round(float(totalPrecentPositive) / len(clean_index), 2) rataNET = round(float(totalPrecentNetral) / len(clean_index), 2) rataNEG = round(float(totalPrecentNegative) / len(clean_index), 2) data_final = [] for i in data_gue: n = i[0].split(',') data_final.append([n[0], n[1], i[1], i[2], i[3]]) print(data_final) framegue = pd.DataFrame.from_dict(data_final) framegue.columns = [ 'Id Dosen', 'Id Mata Kuliah', 'Sentimen Positif (%)', 'Sentimen Netral (%)', 'Sentimen Negatif (%)' ] tahun_ajaran = str(ta) + '_' + str(sem) namaFile = 'app/db/' + str(ta) + '_' + str(sem) + '.csv' try: sentiment_obj = Sentiment(tahun_ajaran=tahun_ajaran, positive=rataPOS, neutral=rataNET, negative=rataNEG) sentiment_obj.save() except Exception as e: print(e) framegue.to_csv(namaFile, quoting=csv.QUOTE_ALL, sep=',', escapechar='"', mode='w', header=True, index=False) return render_template( 'hasil_upload.html', tables=[framegue.to_html(classes='table table-bordered')])
def find_lines(img): # Threshold x gradient sxbinary = abs_sobel_thresh(img, orient='x', thresh_min=50, thresh_max=100) # sbinary = color_transform_thresh(img, thresh_min=100, thresh_max=255) # Threshold the L-channel of HLS hls_l = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)[:,:,1] binary_hls_l = np.zeros_like(hls_l) binary_hls_l[(hls_l > 180) & (hls_l <= 255)] = 1 # Threshold the S-channel of HSV hsv_s = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)[:,:,1] binary_hsv_s = np.zeros_like(hsv_s) binary_hsv_s[(hsv_s >= 180) & (hsv_s <= 255)] = 1 # Threshold the V-channel of HSV hsv_v = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)[:,:,2] binary_hsv_v = np.zeros_like(hsv_v) binary_hsv_v[(hsv_v >= 180) & (hsv_v <= 255)] = 1 # Thresholds the B-channel of LAB lab_b = cv2.cvtColor(img, cv2.COLOR_RGB2Lab)[:,:,2] binary_lab_b = np.zeros_like(lab_b) binary_lab_b[(lab_b > 160) & (lab_b <= 255)] = 1 # Thresholds the L-channel of LUV luv_l = cv2.cvtColor(img, cv2.COLOR_RGB2Luv)[:, :, 0] binary_luv_l = np.zeros_like(luv_l) binary_luv_l[(luv_l > 200) & (luv_l <= 255)] = 1 # # Stack each channel to view their individual contributions in green and blue respectively # # This returns a stack of the two binary images, whose components you can see as different colors # # color_binary = np.dstack(( np.zeros_like(sxbinary), sxbinary, sbinary, binary_hls_l, binary_lab_b )) * 255 # combined_binary = np.zeros_like(sxbinary) combined_binary[(sxbinary == 1) | (binary_lab_b == 1) | (binary_luv_l == 1)] = 1 # Uncomment to view binary image # plt.imshow(combined_binary, cmap='gray') # plt.show() # Perform sliding window search, returns binary_warped image (bird's eye view) binary_warped, Minv = get_birds_eye(combined_binary) # Plotting thresholded images f, (ax1, ax2) = plt.subplots(1, 2, figsize=(20,10)) ax1.set_title('Original Image') ax1.imshow(img) ax2.set_title('Birds-eye-view') ax2.imshow(binary_warped, cmap='gray') plt.show() # Perform sliding window search to identify lane lines left_fitx, right_fitx, \ ploty, left_curverad, \ right_curverad, lane_deviation = sliding_window_search(binary_warped) # Load camera calibration data pickle_data = pickle.load(open('wide_dist_pickle.p', 'rb')) mtx = pickle_data["mtx"] dist = pickle_data["dist"] # Undistort image with calibration data undist = cv2.undistort(img, mtx, dist, None, mtx) # Create an image to draw the lines on warp_zero = np.zeros_like(binary_warped).astype(np.uint8) color_warp = np.dstack((warp_zero, warp_zero, warp_zero)) # Recast the x and y points into usable format for cv2.fillPoly() pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))]) pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))]) pts = np.hstack((pts_left, pts_right)) # Draw the lane onto the warped blank image cv2.fillPoly(color_warp, np.int_([pts]), (255,0, 0)) # Warp the blank back to original image space using inverse perspective matrix (Minv) newwarp = cv2.warpPerspective(color_warp, Minv, (img.shape[1], img.shape[0])) # Combine the result with the original image result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0) font = cv2.FONT_HERSHEY_SIMPLEX cv2.putText(result,"Radius of Curvature = ",(20,40), font, 1, (255,255,255), 2, cv2.LINE_AA) cv2.putText(result,str(int(left_curverad)) + "m",(400,40), font, 1, (255,255,255), 2, cv2.LINE_AA) cv2.putText(result,"Vehicle is ",(20,80), font, 1, (255,255,255), 2, cv2.LINE_AA) cv2.putText(result,str(round(lane_deviation, 3)) + "m left of center",(180,80), font, 1, (255,255,255), 2, cv2.LINE_AA) plt.imshow(result) plt.show() return result
def makeBVFeature(PointCloud_, BoundaryCond, Discretization): # 1024 x 1024 x 3 Height = 1024 + 1 Width = 1024 + 1 # print(Discretization) # Discretize Feature Map PointCloud = np.copy(PointCloud_) PointCloud[:, 0] = np.int_(np.floor(PointCloud[:, 0] / Discretization)) PointCloud[:, 1] = np.int_( np.floor(PointCloud[:, 1] / Discretization) + Width / 2) # sort-3times indices = np.lexsort((-PointCloud[:, 2], PointCloud[:, 1], PointCloud[:, 0])) PointCloud = PointCloud[indices] # Height Map heightMap = np.zeros((Height, Width)) _, indices = np.unique(PointCloud[:, 0:2], axis=0, return_index=True) PointCloud_frac = PointCloud[indices] #some important problem is image coordinate is (y,x), not (x,y) heightMap[np.int_(PointCloud_frac[:, 0]), np.int_(PointCloud_frac[:, 1])] = PointCloud_frac[:, 2] # Intensity Map & DensityMap intensityMap = np.zeros((Height, Width)) densityMap = np.zeros((Height, Width)) _, indices, counts = np.unique(PointCloud[:, 0:2], axis=0, return_index=True, return_counts=True) PointCloud_top = PointCloud[indices] # print(64) # print(np.log(64)) # print(np.log10(10)) normalizedCounts = np.minimum(1.0, np.log10(counts + 1) / 64) intensityMap[np.int_(PointCloud_top[:, 0]), np.int_(PointCloud_top[:, 1])] = PointCloud_top[:, 3] densityMap[np.int_(PointCloud_top[:, 0]), np.int_(PointCloud_top[:, 1])] = normalizedCounts """ plt.imshow(densityMap[:,:]) plt.pause(2) plt.close() plt.show() plt.pause(2) plt.close() plt.show(block=False) plt.pause(2) plt.close() plt.imshow(intensityMap[:,:]) plt.show(block=False) plt.pause(2) plt.close() """ RGB_Map = np.zeros((Height, Width, 3)) RGB_Map[:, :, 0] = densityMap # r_map RGB_Map[:, :, 1] = heightMap # g_map RGB_Map[:, :, 2] = intensityMap # b_map save = np.zeros((512, 1024, 3)) save = RGB_Map[0:512, 0:1024, :] return save
def __init__(self, n_neurons = "micro", # else: "brunel" or arrays C_ab = "micro", # else: "brunel" or arrays area = net.area, # simulation size neuron_model = net.neuron_model, # "iaf_psc_delta" or "iaf_psc_exp" connection_rule = net.connection_rule, # "fixed_total_number" or "fixed_indegree" j02 = net.j02, weight_rel_sd = net.weight_rel_sd, delay_rel_sd = net.delay_rel_sd, g = net.g, rate_ext = net.rate_ext): """Class of network parameters. Contains: - network parameters - single-neuron parameters - stimulus parameters Specify area, neuron_model, neuron_numbers, C_ab, j02, connection_rule, weight_rel_sd, g, rate_ext_factor. Default values correspond to Potjans' model. Neuron numbers and synapse numbers (C_ab) can be specified separately. Both except either a string in {'micro', 'brunel'} or an array of the corresponding shape. Note that V_r, theta, tau_m and rate_ext are already changed to values of the microcircuit model, thus not the original values of the Brunel model. Brunel's model: j02 = 1.0 connection_rule = fixed_indegree weight_rel_sd = 0.0 g, rate_ext varied accordingly Naming: C_ab, C_aext, J_ab, J_ext, rate_ext Don't use conn_probs, K_bg, PSPs, PSP_ext, v_ext, any more! """ ################################################### ### Network parameters ### ################################################### # area of network in mm^2; scales numbers of neurons # use 1 for the full-size network (77,169 neurons) self.area = area self.layers = net.layers #np.array(["L23", "L4", "L5", "L6"]) self.types = net.types #np.array(["e", "i"]) self.populations = np.array([layer + typus for layer in self.layers for typus in self.types]) self.n_populations = len(self.populations) self.n_layers = len(self.layers) self.n_types = len(self.types) # Neuron numbers if n_neurons == "micro": self.n_neurons = np.int_(net.full_scale_n_neurons * self.area) elif n_neurons == "brunel": # Provide an array of equal number of neurons in each exc./inh. population gamma = 0.25 inh_factor = 1. / (gamma + 1.) exc_factor = 1. - inh_factor n_total_micro = np.sum(net.full_scale_n_neurons * self.area) N_exc = n_total_micro/self.n_populations * exc_factor N_inh = n_total_micro/self.n_populations * inh_factor self.n_neurons = np.tile([N_exc, N_inh], self.n_layers).astype(int) else: if type(n_neurons) == np.ndarray: if n_neurons.shape == (self.n_populations, ): self.n_neurons = np.int_(n_neurons) else: raise Exception("'n_neurons' has wrong shape. "+ "Expects (%i,)"%self.n_populations) else: raise Exception("'n_neurons' expects either numpy.ndarray or string "+ "in {'micro', 'brunel'}") self.n_total = np.sum(self.n_neurons) # Synapse numbers # Connection probabilities: conn_probs[post, pre] = conn_probs[target, source] conn_probs = net.conn_probs # Scale synapse numbers of the C_ab if net.scale_C_linearly: n_outer_full = np.outer(net.full_scale_n_neurons, net.full_scale_n_neurons) C_full_scale = np.log(1. - conn_probs) / np.log(1. - 1. / n_outer_full) C_scaled = np.int_(C_full_scale * self.area) else: n_outer = np.outer(self.n_neurons, self.n_neurons) C_scaled = np.int_(np.log(1. - conn_probs) / np.log(1. - 1. / n_outer)) self.connection_rule = connection_rule if self.connection_rule == "fixed_total_number": C_ab_micro = C_scaled # total number, do not divide! elif self.connection_rule == "fixed_indegree": C_ab_micro = (C_scaled.T / (net.full_scale_n_neurons * self.area)).T else: raise Exception("Unexpected connection type. Use 'fixed_total_number' for microcircuit " + "model or 'fixed_indegree' for Brunel's model!") if C_ab == "micro": self.C_ab = C_ab_micro # shall not be integer at this point! elif C_ab == "brunel": C_e = np.mean(C_ab_micro) # mean for microcircuit (= 501 in full scale) C_i = gamma * C_e self.C_ab = np.tile([C_e, C_i], (self.n_populations, self.n_layers)).astype(int) else: if type(C_ab) == np.ndarray: if C_ab.shape == (self.n_populations, self.n_populations): self.C_ab = np.int_(C_ab) else: raise Exception("'C_ab' has wrong shape. "+ "Expects (%i, %i)"%(self.n_populations, self.n_populations)) else: raise Exception("'C_ab' expects either numpy.ndarray or string "+ "in {'micro', 'brunel'}") ################################################### ### Single-neuron parameters ### ################################################### self.neuron_model = neuron_model self.Vm0_mean = net.Vm0_mean # mean of initial membrane potential (mV) self.Vm0_std = net.Vm0_std # std of initial membrane potential (mV) self.model_params = net.model_params if not self.neuron_model=="iaf_psc_delta": self.model_params["tau_syn_ex"] = net.tau_syn_ex # excitatory synaptic time constant (ms) self.model_params["tau_syn_in"] = net.tau_syn_in # inhibitory synaptic time constant (ms) self.tau_syn_ex = net.tau_syn_ex # ms self.tau_syn_in = net.tau_syn_in # ms self.tau_syn = np.tile([self.tau_syn_ex, self.tau_syn_in], (self.n_populations, self.n_layers)) # Rescaling for model calculations: these values are not used in the simulation! self.tau_m = self.model_params["tau_m"] # ms self.t_ref = self.model_params["t_ref"] # ms self.E_L = self.model_params["E_L"] # mV self.V_r = self.model_params["V_reset"] - self.E_L # mV self.theta = self.model_params["V_th"] - self.E_L # mV self.C_m = self.model_params["C_m"] # pF ###################################################### # Synaptic weights. Depend on neuron_model! ## ###################################################### self.g = g self.j02 = j02 g_all = np.tile([1., -self.g], (self.n_populations, self.n_layers)) L23e_index = np.where(self.populations == "L23e")[0][0] L4e_index = np.where(self.populations == "L4e")[0][0] g_all[L23e_index, L4e_index] *= self.j02 self.J = net.PSP_e # mv; mean PSP, used as reference PSP self.J_ab = self.J * g_all self.weight_rel_sd = weight_rel_sd # Standard deviation of weight relative to mean weight # Transformation from peak PSP to PSC delta_tau = self.tau_syn - self.tau_m ratio_tau = self.tau_m / self.tau_syn PSC_over_PSP = self.C_m * delta_tau / (self.tau_m * self.tau_syn * \ (ratio_tau**(self.tau_m / delta_tau) - ratio_tau**(self.tau_syn / delta_tau))) # Actual weights have to be adapted: from peak PSP to PSC (and back...) if self.neuron_model=="iaf_psc_exp": # PSCs calculated from PSP amplitudes self.weights = self.J_ab * PSC_over_PSP # neuron populations elif self.neuron_model=="iaf_psc_delta": self.weights = self.J_ab * PSC_over_PSP * (self.tau_syn_ex) / self.C_m # This might be an overkill / doing things twice... elif self.neuron_model=="iaf_psc_alpha": # PSCs calculated from PSP amplitudes self.weights = self.J_ab * np.exp(1) / (self.tau_syn_ex) / self.C_m else: raise Exception("Neuron model should be iaf_psc_ - {delta, exp, alpha}!") ################################################### ### Delays and dicts ### ################################################### # mean dendritic delays for excitatory and inhibitory transmission (ms) self.delay_e = net.delay_e # ms, excitatory synapses self.delay_i = net.delay_i # ms, inhibitory synapses self.delays = np.tile([self.delay_e, self.delay_i], (self.n_populations, self.n_layers)) # adapt... self.delay_rel_sd = delay_rel_sd # Synapse dictionaries # default connection dictionary self.conn_dict = {"rule": connection_rule} # weight distribution of connections between populations self.weight_dict_exc = net.weight_dict_exc self.weight_dict_inh = net.weight_dict_inh # delay distribution of connections between populations self.delay_dict = net.delay_dict # default synapse dictionary self.syn_dict = net.syn_dict ################################################### ### External stimuli ## ################################################### # rate of background Poisson input at each external input synapse (spikes/s) self.rate_ext = rate_ext # Hz self.J_ext = net.PSP_ext # external synaptic weight self.delay_ext = self.delay_e # ms; mean delay of external input self.dc_amplitude = net.dc_amplitude # constant bg amplitude self.C_aext = net.C_aext # in-degrees for background input # Adapt weights if self.neuron_model=="iaf_psc_exp": # PSCs calculated from PSP amplitudes self.weight_ext = self.J_ext * PSC_over_PSP[0, 0] elif self.neuron_model=="iaf_psc_delta": self.weight_ext = self.J_ext * PSC_over_PSP[0, 0] * self.tau_syn_ex / self.C_m elif self.neuron_model=="iaf_psc_alpha": # PSCs calculated from PSP amplitudes self.weight_ext = self.J_ext * np.exp(1) / self.tau_syn_ex / self.C_m # optional additional thalamic input (Poisson) self.n_th = net.n_th # size of thalamic population self.th_start = net.th_start # onset of thalamic input (ms) self.th_duration = net.th_duration # duration of thalamic input (ms) self.th_rate = net.th_rate # rate of thalamic neurons (spikes/s) self.J_th = net.PSP_th # mean EPSP amplitude (mV) for thalamic input # Adapt weights if self.neuron_model=="iaf_psc_exp": # PSCs calculated from PSP amplitudes self.weight_th = self.J_th * PSC_over_PSP[0, 0] elif self.neuron_model=="iaf_psc_delta": self.weight_th = self.J_th * PSC_over_PSP[0, 0] * self.tau_syn_ex / self.C_m elif self.neuron_model=="iaf_psc_alpha": # PSCs calculated from PSP amplitudes self.weight_th = self.J_th * np.exp(1) / self.tau_syn_ex / self.C_m # connection probabilities for thalamic input conn_probs_th = net.conn_probs_th if net.scale_C_linearly: if not self.n_th == 0: C_th_full_scale = np.log(1. - conn_probs_th) / \ np.log(1. - 1. / (self.n_th * net.full_scale_n_neurons)) self.C_th_scaled = np.int_(C_th_full_scale * self.area) else: if not self.n_th == 0: self.C_th_scaled = np.int_(np.log(1. - conn_probs_th) / \ np.log(1. - 1. / (self.n_th * self.n_neurons_micro))) if self.n_th == 0: self.C_th_scaled = None # mean delay of thalamic input (ms) self.delay_th = net.delay_th # standard deviation relative to mean delay of thalamic input self.delay_th_rel_sd = net.delay_th_rel_sd ###################################################### # Predefine matrices for mean field ## ###################################################### if self.neuron_model=="iaf_psc_delta": self.J_mu = self.weights self.J_sd = self.weights self.J_mu_ext = self.weight_ext self.J_sd_ext = self.weight_ext elif self.neuron_model=="iaf_psc_exp": self.J_mu = self.weights * self.tau_syn / self.C_m self.J_sd = self.weights * np.sqrt(self.tau_syn / 2.) / self.C_m self.J_mu_ext = self.weight_ext * self.tau_syn_ex / self.C_m self.J_sd_ext = self.weight_ext * np.sqrt(self.tau_syn_ex / 2.) / self.C_m elif self.neuron_model=="iaf_psc_alpha": self.J_mu = self.weights * self.tau_syn**2 / self.C_m self.J_sd = self.weights * self.tau_syn**(3./2.) / (self.C_m * 2.) self.J_mu_ext = self.weight_ext * self.tau_syn_ex**2 / self.C_m self.J_sd_ext = self.weight_ext * self.tau_syn_ex**(3./2.) / (self.C_m * 2.) self.mat_mu = self.tau_m * 1e-3 * self.J_mu * self.C_ab self.mu_ext = self.tau_m * 1e-3 * self.J_mu_ext * self.C_aext * self.rate_ext self.mat_var = self.tau_m * 1e-3 * (1 + self.weight_rel_sd ** 2) * self.J_sd**2 * self.C_ab self.var_ext = self.tau_m * 1e-3 * (1 + self.weight_rel_sd ** 2) * self.J_sd_ext**2 * self.C_aext * self.rate_ext
def pose_change_a_to_b(frame_a, frame_b): try: first_img = frame_a.get_amplitude_image() # adjust image sizes # first_img = np.float32(np.gradient(data.normalize_full(first_img), 2, axis=0, edge_order=2)) first_img = np.uint8(filter_image(first_img) * 255) second_img = frame_b.get_amplitude_image() # second_img = np.float32(np.gradient(data.normalize_full(second_img), 2, axis=0, edge_order=2)) second_img = np.uint8(filter_image(second_img) * 255) sift_img = cv2.xfeatures2d.SIFT_create(contrastThreshold=0.0015, edgeThreshold=10, nOctaveLayers=3, sigma=1.2) mask = np.zeros_like(first_img) mask[frame_a.confidence >= 6] = 1 kp1, desc1 = sift_img.detectAndCompute(first_img, mask=mask) # sift test first image mask[frame_b.confidence >= 6] = 1 kp2, desc2 = sift_img.detectAndCompute(second_img, mask=mask) # sift second image img1_points = [] img2_points = [] detected_feature_loc1 = [] detected_feature_loc2 = [] if desc1 is None or desc2 is None or not kp1 or not kp2: # remove frames that don't have anything pass # cv2.imshow(frame_text + " 1", first_img) # cv2.imshow(frame_text + " 2", second_img) else: compare_desc = cv2.BFMatcher() # setup brute force matcher match = compare_desc.knnMatch(desc1, desc2, k=2) j = 0 for points, points2 in match: # { if points.distance > 0.55 * points2.distance: continue # get the x and y pixel locations the features from the matcher # get points from the key points array that were matched (x1, y1) = kp1[points.queryIdx].pt (x2, y2) = kp2[points.trainIdx].pt # point pairs for each image, indices match pairs # array to hold all (x,y) pixel loc of features img1_points = np.append(img1_points, [x1, y1]) img2_points = np.append(img2_points, [x2, y2]) # round values and cast to integer img1_points = np.int_(np.round(img1_points, decimals=0, out=None)) img2_points = np.int_(np.round(img2_points, decimals=0, out=None)) # img1_points = img1_points[status == 1] # img2_points = img2_points[status == 1] # get the xvect, yvect, and z distance of each point of interest based on the pixel xy location # and round to 4 decimal places. final full array of all matching points feature_loc1 = np.round(frame_a.get_position(img1_points[j * 2], img1_points[j * 2 + 1]), 4) feature_loc2 = np.round(frame_b.get_position(img2_points[j * 2], img2_points[j * 2 + 1]), 4) detected_feature_loc1 = np.append(detected_feature_loc1, (feature_loc1[1], feature_loc1[2], feature_loc1[0])) detected_feature_loc2 = np.append(detected_feature_loc2, (feature_loc2[1], feature_loc2[2], feature_loc2[0])) j += 1 img1_points = np.reshape(img1_points, (-1, 1, 2)) img2_points = np.reshape(img2_points, (-1, 1, 2)) # print("img1 points: ", img1_points) H, status = cv2.findHomography(img1_points, img2_points, cv2.RANSAC, ransacReprojThreshold=0.999) detected_feature_loc1 = np.reshape(detected_feature_loc1, (-1, 1, 3)) detected_feature_loc2 = np.reshape(detected_feature_loc2, (-1, 1, 3)) # print("img1 points: ", detected_feature_loc1) detected_feature_loc1 = detected_feature_loc1[status == 1] detected_feature_loc2 = detected_feature_loc2[status == 1] img1_points = img1_points[status == 1] img2_points = img2_points[status == 1] # show two original frames and matched features # display = np.hstack((first_img, second_img)) display = second_img img1_points = img1_points.reshape((-1, 2)) img2_points = img2_points.reshape((-1, 2)) display = calc.render_keypoints(display, img2_points, img1_points, scale=3) # , offset=(first_img.shape[1], 0)) cv2.imshow(frame_text, display) # cv2.waitKey(10) # after each image loop before getting next image # reshape vector into 3D array then take transpose detected_feature_loc1 = np.reshape(detected_feature_loc1, (-1, 3)) # format [[x1y1z1][x2y2z2]] detected_feature_loc2 = np.reshape(detected_feature_loc2, (-1, 3)) # format [[x1y1z1][x2y2z2]] detected_feature_loc1_tuple = tuple(detected_feature_loc1) detected_feature_loc2_tuple = tuple(detected_feature_loc2) tupled_features = [[tuple(x), tuple(y)] for x, y in zip(detected_feature_loc1, detected_feature_loc2)] # send to ransac calculation param = RansacParams(samples=4, iterations=15, confidence=0.9, threshold=ransac_thresh) my_model = ThreeD() found_inliers = find_inliers(tupled_features, my_model, param) # print(found_inliers) if len(found_inliers) < 4: return None print("\tnumber of inliers: ", len(found_inliers)) # inlier_count = np.append(inlier_count, len(found_inliers)) except: traceback.print_exc() return None # return np.mat(np.eye(3)), np.mat(np.zeros(3).T) return my_model.rotate, my_model.translate
def extract_image_patches(image, patch_size, max_number_of_patches='all', stride_length=1, mask_image=None, random_seed=None, return_as_array=False): """ Extract 2-D or 3-D image patches. Arguments --------- image : ANTsImage Input image with one or more components. patch_size: n-D tuple (depending on dimensionality). Width, height, and depth (if 3-D) of patches. max_number_of_patches: integer or string Maximum number of patches returned. If "all" is specified, then all patches in sequence (defined by the stride_length are extracted. stride_length: integer or n-D tuple Defines the sequential patch overlap for max_number_of_patches = "all". Can be a image-dimensional vector or a scalar. mask_image: ANTsImage (optional) Optional image specifying the sampling region for the patches when max_number_of_patches does not equal "all". The way we constrain patch selection using a mask is by forcing each returned patch to have a masked voxel at its center. random_seed: integer (optional) Seed value that allows reproducible patch extraction across runs. return_as_array: boolean Specifies the return type of the function. If False (default) the return type is a list where each element is a single patch. Otherwise the return type is an array of size dim( number_of_patches, patch_size ). Returns ------- A list (or array) of patches. Example ------- >>> import ants >>> image = ants.image_read(ants.get_ants_data('r16')) >>> image_patches = extract_image_patches(image, patch_size=(32, 32)) """ if random_seed is not None: random.seed(random_seed) image_size = image.shape dimensionality = image.dimension if dimensionality != 2 and dimensionality != 3: raise ValueError("Unsupported dimensionality.") number_of_image_components = image.components if len(image_size) != len(patch_size): raise ValueError("Mismatch between the image size and the specified patch size.") if patch_size > image_size: raise ValueError("Patch size is greater than the image size.") image_array = image.numpy() if number_of_image_components > 1: if dimensionality == 2: image_array = np.transpose(image_array, [1, 2, 0]) else: image_array = np.transpose(image_array, [1, 2, 3, 0]) patch_list = [] patch_array = np.empty([1, 1]) mid_patch_index = tuple(np.int_(np.subtract(np.round(0.5 * (np.array(patch_size))), 1))) number_of_extracted_patches = max_number_of_patches if isinstance(max_number_of_patches, str) and max_number_of_patches.lower() == 'all': stride_length_tuple = stride_length if isinstance(stride_length, int): stride_length_tuple = tuple(np.multiply(np.ones_like(patch_size), stride_length)) elif len(stride_length) != dimensionality: raise ValueError("stride_length is not a scalar or vector of length dimensionality.") elif np.any(np.less(stride_length, 1)): raise ValueError("stride_length elements must be positive integers.") number_of_extracted_patches = 1 indices = [] for d in range(dimensionality): indices.append(range(0, image_size[d] - patch_size[d] + 1, stride_length_tuple[d])) number_of_extracted_patches *= len(indices[d]) if return_as_array: if number_of_image_components == 1: patch_array = np.zeros((number_of_extracted_patches, *patch_size)) else: patch_array = np.zeros((number_of_extracted_patches, *patch_size, number_of_image_components)) count = 0 if dimensionality == 2: for i in indices[0]: for j in indices[1]: start_index = (i, j) end_index = tuple(np.add(start_index, patch_size)) if number_of_image_components == 1: patch = image_array[start_index[0]:end_index[0], start_index[1]:end_index[1]] else: patch = image_array[start_index[0]:end_index[0], start_index[1]:end_index[1],:] if return_as_array: if number_of_image_components == 1: patch_array[count, :, :] = patch else: patch_array[count, :, :, :] = patch else: patch_list.append(patch) count += 1 else: for i in indices[0]: for j in indices[1]: for k in indices[2]: start_index = (i, j, k) end_index = tuple(np.add(start_index, patch_size)) if number_of_image_components == 1: patch = image_array[start_index[0]:end_index[0], start_index[1]:end_index[1], start_index[2]:end_index[2]] else: patch = image_array[start_index[0]:end_index[0], start_index[1]:end_index[1], start_index[2]:end_index[2],:] if return_as_array: if number_of_image_components == 1: patch_array[count, :, :, :] = patch else: patch_array[count, :, :, :, :] = patch else: patch_list.append(patch) count += 1 else: random_indices = np.zeros((max_number_of_patches, dimensionality), dtype=int) if mask_image != None: mask_array = mask_image.numpy() mask_array[np.where(mask_array != 0)] = 1 # The way we constrain patch selection using a mask is by assuming that # each patch must have a masked voxel at its midPatchIndex. mask_indices = np.column_stack(np.where(mask_array != 0)) for d in range(dimensionality): shifted_mask_indices = np.subtract(mask_indices[:, d], mid_patch_index[d]) outside_indices = np.where(shifted_mask_indices < 0) mask_indices = np.delete(mask_indices, outside_indices, axis = 0) shifted_mask_indices = np.add(mask_indices[d], mid_patch_index[d]) outside_indices = np.where(shifted_mask_indices >= image_size[d]) mask_indices = np.delete(mask_indices, outside_indices, axis = 0) # After pruning the mask indices, which were originally defined in terms of the # mid_patch_index, we subtract the midPatchIndex so that it's now defined at the # corner for patch selection. for d in range(dimensionality): mask_indices[:, d] = np.subtract(mask_indices[:, d], mid_patch_index[d]) number_of_extracted_patches = min(max_number_of_patches, mask_indices.shape[0]) random_indices = mask_indices[ random.sample(range(mask_indices.shape[0] + 1), number_of_extracted_patches), :] else: for d in range(dimensionality): random_indices[:, d] = random.sample(range(image_size[d] - patch_size[d] + 1), max_number_of_patches) if return_as_array: if number_of_image_components == 1: patch_array = np.zeros((number_of_extracted_patches, *patch_size)) else: patch_array = np.zeros((number_of_extracted_patches, *patch_size, number_of_image_components)) start_index = np.ones( dimensionality ) for i in range(number_of_extracted_patches): start_index = random_indices[i, :] end_index = np.add(start_index, patch_size) if dimensionality == 2: if number_of_image_components == 1: patch = image_array[start_index[0]:end_index[0], start_index[1]:end_index[1]] else: patch = image_array[start_index[0]:end_index[0], start_index[1]:end_index[1], :] else: if number_of_image_components == 1: patch = image_array[start_index[0]:end_index[0], start_index[1]:end_index[1], start_index[2]:end_index[2]] else: patch = image_array[start_index[0]:end_index[0], start_index[1]:end_index[1], start_index[2]:end_index[2], :] if return_as_array: if dimensionality == 2: if number_of_image_components == 1: patch_array[i, :, :] = patch else: patch_array[i, :, :, :] = patch else: if number_of_image_components == 1: patch_array[i, :, :] = patch else: patch_array[i, :, :, :, :] = patch else: patch_list.append(patch) if return_as_array: return(patch_array) else: return(patch_list)
def _convert_state_to_bbox(self, state): return Rect(tf_rect=np.int_(np.round(state[:4, 0])))
def makeBVFeature(PointCloud_origin, BoundaryCond, size_cell): # Discretization:ROI长度(m)/该长度方向上的栅格数,即每个cell的边长 Height = 700 Width = 500 PointCloud = removePoints(PointCloud_origin, BoundaryCond) PointCloud[:, 0] = BoundaryCond['maxX'] - PointCloud[:, 0] # 坐标系统一为左上角 PointCloud[:, 1] = BoundaryCond['maxY'] - PointCloud[:, 1] # PointCloud_grid = np.copy(PointCloud ) PointCloud[:, 0] = np.int_(np.floor(PointCloud[:, 0] / size_cell)) # np.floor 返回不大于输入参数的最大整数; PointCloud[:, 1] = np.int_(np.floor( PointCloud[:, 1] / size_cell)) # 将点云坐标转化为栅格坐标,python数组从0开始,所以不用+1,matlab从0开始,所以需要+1 # sort-3times indices = np.lexsort( (-PointCloud[:, 2], PointCloud[:, 1], PointCloud[:, 0]) ) # np.lexsort((b,a)) 先对a排序,再对b.排序按x轴(栅格)进行从小到大排列,当x值相同时,按y轴(栅格)从小到大排序,y也相同时,按z从大到小排序 PointCloud = PointCloud[ indices] # 目的是将每个栅格的最大z排在最前面,下面unique时,便只会保留z最大值(排在第一位)的索引 # Height Map& DensityMap heightMap = np.zeros( (Height, Width)) # 括号括起来 表示是一个参数,即np.zeros()的第一个参数是(Height,Width) densityMap = np.zeros((Height, Width)) _, indices, counts = np.unique(PointCloud[:, 0:2], axis=0, return_index=True, return_counts=True) PointCloud_frac = PointCloud[indices] # counts返回的是每个元素在原始数组出现的次数,这里是每个栅格中 # some important problem is image coordinate is (y,x), not (x,y) height_z = np.int(BoundaryCond['maxZ']) - np.int(BoundaryCond['minZ']) heightMap[np.int_(PointCloud_frac[:, 0]), np.int_(PointCloud_frac[:, 1])] = (PointCloud_frac[:, 2] + 2) / height_z heightMap.astype(np.int32) normalizedCounts = np.minimum(1.0, np.log(counts + 1) / np.log(64)) # 即normalizedCounts最大为1 densityMap[np.int_(PointCloud_frac[:, 0]), np.int_(PointCloud_frac[:, 1])] = normalizedCounts / 1 #densityMap=densityMap.astype(np.uint8) intensityMap = np.zeros((Height, Width)) indices = np.lexsort((-PointCloud[:, 3], PointCloud[:, 1], PointCloud[:, 0])) # 按x由小到大,y由小到大, intensity由大到小 PointCloud_intensity = PointCloud[indices] _, indices = np.unique(PointCloud_intensity[:, 0:2], axis=0, return_index=True) # 只保留每个栅格中intensity最大的点 PointCloud_max_intensity = PointCloud_intensity[indices] intensityMap[np.int_(PointCloud_max_intensity[:, 0]), np.int_(PointCloud_max_intensity[:, 1] )] = PointCloud_max_intensity[:, 3] # 将反射强度放大100倍 #intensityMap=intensityMap.astype(np.uint8) RGB_Map = np.zeros((Height, Width, 3)) RGB_Map[:, :, 0] = densityMap # r_map RGB_Map[:, :, 1] = heightMap # g_map RGB_Map[:, :, 2] = intensityMap # b_map grid_picture = RGB_Map[0:Height, 0:Width, :] #grid_picture = grid_picture.astype(np.uint8) grid_picture = np.ceil(grid_picture[:, :, ::-1] * 255) grid_picture = grid_picture.astype(np.uint8) #cv2.imwrite('outimage/1.png', grid_picture) # grid_picture=np.ceil(grid_picture) # grid_picturenew=grid_picture.astype(np.uint8) return grid_picture
def search_around_poly(warped_binary): # Choose the width of the margin around the previous polynomial to search margin = 40 # Grab activated pixels nonzero = binary_warped.nonzero() nonzeroy = np.array(nonzero[0]) nonzerox = np.array(nonzero[1]) # Search within the polynomial based area left_lane_inds = ( (nonzerox > (left_fit[0] * (nonzeroy**2) + left_fit[1] * nonzeroy + left_fit[2] - margin)) & (nonzerox < (left_fit[0] * (nonzeroy**2) + left_fit[1] * nonzeroy + left_fit[2] + margin))) right_lane_inds = ( (nonzerox > (right_fit[0] * (nonzeroy**2) + right_fit[1] * nonzeroy + right_fit[2] - margin)) & (nonzerox < (right_fit[0] * (nonzeroy**2) + right_fit[1] * nonzeroy + right_fit[2] + margin))) # Again, extract left and right line pixel positions leftx = nonzerox[left_lane_inds] lefty = nonzeroy[left_lane_inds] rightx = nonzerox[right_lane_inds] righty = nonzeroy[right_lane_inds] # Fit new polynomials left_fitx, right_fitx, ploty = fit_poly(binary_warped.shape, leftx, lefty, rightx, righty) # Create an image to draw on and an image to show the selection window out_img = np.dstack((binary_warped, binary_warped, binary_warped)) * 255 window_img = np.zeros_like(out_img) # Colors in the left and right lane regions out_img[lefty, leftx] = [255, 0, 0] out_img[righty, rightx] = [0, 0, 255] # Generate a polygon to illustrate the search window area # And recast the x and y points into usable format for cv2.fillPoly() left_line_window1 = np.array( [np.transpose(np.vstack([left_fitx - margin, ploty]))]) left_line_window2 = np.array( [np.flipud(np.transpose(np.vstack([left_fitx + margin, ploty])))]) left_line_pts = np.hstack((left_line_window1, left_line_window2)) right_line_window1 = np.array( [np.transpose(np.vstack([right_fitx - margin, ploty]))]) right_line_window2 = np.array( [np.flipud(np.transpose(np.vstack([right_fitx + margin, ploty])))]) right_line_pts = np.hstack((right_line_window1, right_line_window2)) # Draw the lane onto the warped blank image cv2.fillPoly(window_img, np.int_([left_line_pts]), (0, 255, 0)) cv2.fillPoly(window_img, np.int_([right_line_pts]), (0, 255, 0)) result = cv2.addWeighted(out_img, 1, window_img, 0.3, 0) # # Plot the polynomial lines onto the image # plt.plot(left_fitx, ploty, color='yellow') # plt.plot(right_fitx, ploty, color='yellow') return result, left_fit, right_fit, ploty
def search_around_poly(binary_warped): # HYPERPARAMETER # Choose the width of the margin around the previous polynomial to search # The quiz grader expects 100 here, but feel free to tune on your own! margin = 100 # Grab activated pixels nonzero = binary_warped.nonzero() nonzeroy = np.array(nonzero[0]) nonzerox = np.array(nonzero[1]) ### TO-DO: Set the area of search based on activated x-values ### ### within the +/- margin of our polynomial function ### ### Hint: consider the window areas for the similarly named variables ### ### in the previous quiz, but change the windows to our new search area ### left_lane_inds = ( (nonzerox > (left_fit[0] * (nonzeroy**2) + left_fit[1] * nonzeroy + left_fit[2] - margin)) & (nonzerox < (left_fit[0] * (nonzeroy**2) + left_fit[1] * nonzeroy + left_fit[2] + margin))) right_lane_inds = ( (nonzerox > (right_fit[0] * (nonzeroy**2) + right_fit[1] * nonzeroy + right_fit[2] - margin)) & (nonzerox < (right_fit[0] * (nonzeroy**2) + right_fit[1] * nonzeroy + right_fit[2] + margin))) # Again, extract left and right line pixel positions leftx = nonzerox[left_lane_inds] lefty = nonzeroy[left_lane_inds] rightx = nonzerox[right_lane_inds] righty = nonzeroy[right_lane_inds] # Fit new polynomials left_fitx, right_fitx, ploty = fit_poly(binary_warped.shape, leftx, lefty, rightx, righty) ## Visualization ## # Create an image to draw on and an image to show the selection window out_img = np.dstack((binary_warped, binary_warped, binary_warped)) * 255 window_img = np.zeros_like(out_img) # Color in left and right line pixels out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0] out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [0, 0, 255] # Generate a polygon to illustrate the search window area # And recast the x and y points into usable format for cv2.fillPoly() left_line_window1 = np.array( [np.transpose(np.vstack([left_fitx - margin, ploty]))]) left_line_window2 = np.array( [np.flipud(np.transpose(np.vstack([left_fitx + margin, ploty])))]) left_line_pts = np.hstack((left_line_window1, left_line_window2)) right_line_window1 = np.array( [np.transpose(np.vstack([right_fitx - margin, ploty]))]) right_line_window2 = np.array( [np.flipud(np.transpose(np.vstack([right_fitx + margin, ploty])))]) right_line_pts = np.hstack((right_line_window1, right_line_window2)) # Draw the lane onto the warped blank image cv2.fillPoly(window_img, np.int_([left_line_pts]), (10, 255, 100)) cv2.fillPoly(window_img, np.int_([right_line_pts]), (0, 255, 0)) result = cv2.addWeighted(out_img, 1, window_img, 0.3, 0) # Plot the polynomial lines onto the image plt.plot(left_fitx, ploty, color='yellow') plt.plot(right_fitx, ploty, color='yellow') ## End visualization steps ## return result
def predict(pred_func, input_file): for frame_name in os.listdir(input_file): intensity_file = pd.read_csv(os.path.join(intensity_path, frame_name)) pts_file = pd.read_csv(os.path.join(pts_path, frame_name)) file_name = str.split(frame_name, '.')[0] pts = pd.read_csv(os.path.join(pts_path, file_name + '.csv'), header=None) pts = np.array(pts) out = np.zeros((len(pts), 1), dtype=np.int8) start = time.time() PointCloud = np.hstack((pts_file, intensity_file)) img = makeBVFeature(PointCloud, size_ROI, size_cell) results = detect_one_image(img, pred_func) #objectfile=open('results1/%s.txt'%file_name,'w') pts[:, 0] = maxX - pts[:, 0] # 坐标系统一为左上角 pts[:, 1] = maxY - pts[:, 1] # PointCloud_grid = np.copy(PointCloud ) pts[:, 0] = np.int_(np.floor(pts[:, 0] / size_cell)) # np.floor 返回不大于输入参数的最大整数; pts[:, 1] = np.int_(np.floor(pts[:, 1] / size_cell)) for r in results: label = cfg.DATA.CLASS_NAMES[r.class_id][0:3] #if r.score<0.4: #label=0 indx = np.where((pts[:, 1] > int(r[0][0])) & (pts[:, 1] < int(r[0][2])) & (pts[:, 0] < int(r[0][3])) & (pts[:, 0] > int(r[0][1]))) if label == 'cyc': if r.score < 0.6: label = 0 else: label = 1 # indx = np.where( # (pts[:, 1] > int(r[0][0])) & (pts[:, 1] < int(r[0][2])) & (pts[:, 0] < int(r[0][3])) & (pts[:, 0] > int(r[0][1]))& (pts[:, 2] <-0.3)) elif label == 'tri': label = 2 # indx = np.where( # (pts[:, 1] > int(r[0][0])) & (pts[:, 1] < int(r[0][2])) & (pts[:, 0] < int(r[0][3])) & ( # pts[:, 0] > int(r[0][1])) & (pts[:, 2] < -0.3)) elif label == 'sma': label = 3 # indx = np.where( # (pts[:, 1] > int(r[0][0])) & (pts[:, 1] < int(r[0][2])) & (pts[:, 0] < int(r[0][3])) & ( # pts[:, 0] > int(r[0][1])) & (pts[:, 2] < 0)) elif label == 'big': label = 4 # indx = np.where( # (pts[:, 1] > int(r[0][0])) & (pts[:, 1] < int(r[0][2])) & (pts[:, 0] < int(r[0][3])) & ( # pts[:, 0] > int(r[0][1])) ) elif label == 'ped': if r.score < 0.4: label = 0 else: label = 5 #label = 5 # indx = np.where( # (pts[:, 1] > int(r[0][0])) & (pts[:, 1] < int(r[0][2])) & (pts[:, 0] < int(r[0][3])) & ( # pts[:, 0] > int(r[0][1])) & (pts[:, 2] < -0.1)) elif label == 'cro': label = 6 # indx = np.where( # (pts[:, 1] > int(r[0][0])) & (pts[:, 1] < int(r[0][2])) & (pts[:, 0] < int(r[0][3])) & ( # pts[:, 0] > int(r[0][1])) & (pts[:, 2] < -0.1)) elif label == 'unk': if r.score < 0.3: label = 0 # else: # label=7 # indx = np.where( # (pts[:, 1] > int(r[0][0])) & (pts[:, 1] < int(r[0][2])) & (pts[:, 0] < int(r[0][3])) & ( # pts[:, 0] > int(r[0][1])) ) label = 7 out[indx] = label end = time.time() np.savetxt(os.path.join(upload_path, file_name + '.csv'), out, delimiter=',', fmt='%d') print(end - start)
def run(self, img, debug=False): und_img = self.undistort(img) if debug is True: plt.imshow(und_img) plt.title('undistorted image') plt.show() res_img = self.transform_img(und_img, debug) if debug is True: plt.imshow(res_img, cmap='gray') plt.title('transformed image') plt.show() warped_img = self.warp_img(res_img, debug) if debug is True: plt.imshow(warped_img, cmap='gray') plt.title('warped image') plt.show() print(warped_img.shape) # detect line within the img left, right = self.find_lines(warped_img, debug) if debug is True: #draw line on top of warped_img temp_warpimg = np.copy(warped_img) tempcolor_warp = (np.dstack( (temp_warpimg, temp_warpimg, temp_warpimg)) * 255).astype( np.uint8) pts_left = np.array( [np.transpose(np.vstack([left.allx, left.ally]))]) pts_right = np.array( [np.flipud(np.transpose(np.vstack([right.allx, right.ally])))]) # pts = np.hstack((pts_left, pts_right) pts_left = pts_left.reshape((-1, 1, 2)) pts_right = pts_right.reshape((-1, 1, 2)) cv2.polylines(tempcolor_warp, np.int_([pts_left]), False, (0, 0, 255), thickness=5) cv2.polylines(tempcolor_warp, np.int_([pts_right]), False, (255, 0, 0), thickness=5) plt.imshow(tempcolor_warp) plt.title('detected lines') plt.show() left, right = self.lane.line_detected_current_frame(left, right) lane_detected = self.draw(warped_img, left, right, debug) if debug is True: plt.imshow(lane_detected) plt.title('lane detected') plt.show() # Combine the result with the original image result = cv2.addWeighted(img, 1, lane_detected, 0.3, 0) # add text on image curve_text = "curvature:" + '{:.3f}'.format(self.lane.get_curvature()) self.write_on_image(result, curve_text, location=(10, 50)) road_width = "lane width:" + '{:.3f}'.format(self.lane.get_lanewidth()) self.write_on_image(result, road_width, location=(10, 150)) offset_text = "offset from center:" + '{:.3f}'.format( self.lane.get_offset(result.shape[1])) self.write_on_image(result, offset_text, location=(10, 100)) return result
def index_from_nearest_path_with_pt_in_bbox_( level_index, l_i, nb_c_per_l, nb_pt_per_c, indices_of_first_pts, x_value, y_value, x_min_per_c, y_min_per_c, x_max_per_c, y_max_per_c, xpt, ypt, ): """Get index from nearest path in edge bbox contain pt """ # Nb contour in level if nb_c_per_l[level_index] == 0: return -1 # First contour in level i_start_c = l_i[level_index] # First contour of the next level i_end_c = i_start_c + nb_c_per_l[level_index] # Flag to check if we iterate find_contour = 0 # We select the first pt of the first contour in the level # to initialize dist i_ref = i_start_c i_start_pt = indices_of_first_pts[i_start_c] dist_ref = (x_value[i_start_pt] - xpt)**2 + (y_value[i_start_pt] - ypt)**2 # We iterate over contour in the same level for i_elt_c in range(i_start_c, i_end_c): # if bbox of contour doesn't contain pt, we skip this contour if y_min_per_c[i_elt_c] > ypt: continue if y_max_per_c[i_elt_c] < ypt: continue x_min = x_min_per_c[i_elt_c] xpt_ = (xpt - x_min) % 360 + x_min if x_min > xpt_: continue if x_max_per_c[i_elt_c] < xpt_: continue # Indice of first pt of contour i_start_pt = indices_of_first_pts[i_elt_c] # Indice of first pt of the next contour i_end_pt = i_start_pt + nb_pt_per_c[i_elt_c] # We set flag to true, because we check contour find_contour = 1 # We do iteration on pt to check dist, if it's inferior we store # index of contour for i_elt_pt in range(i_start_pt, i_end_pt): d_x = x_value[i_elt_pt] - xpt_ if abs(d_x) > 180: d_x = (d_x + 180) % 360 - 180 dist = d_x**2 + (y_value[i_elt_pt] - ypt)**2 if dist < dist_ref: dist_ref = dist i_ref = i_elt_c # No iteration on contour, we return no index of contour if find_contour == 0: return int_(-1) # We return index of contour, for the specific level return int_(i_ref - i_start_c)
def makeBVFeature(PointCloud_, BoundaryCond, Discretization): # Dis= Height = Discretization + 1 # Width = Discretization + 1 # Discretize Feature Map PointCloud = np.copy(PointCloud_) PointCloud[:, 0] = np.int_( np.floor(PointCloud[:, 0] / abs(BoundaryCond['maxX'] - BoundaryCond['minX']) * Discretization)) # x 倍增 PointCloud[:, 1] = np.int_( np.floor(PointCloud[:, 1] / abs(BoundaryCond['maxY'] - BoundaryCond['minY']) * Discretization)) # y, 倍增+平移 indices = np.lexsort((PointCloud[:, 1], PointCloud[:, 2], PointCloud[:, 0])) PointCloud = PointCloud[indices] # Height Map & Intensity Map & DensityMap heightMap = np.zeros((Height, Width)) # 空 矩阵 intensityMap = np.zeros((Height, Width)) densityMap = np.zeros((Height, Width)) #_, indices = np.unique(PointCloud[:, 0:2], axis=0, return_index=True) # 去重 _, indices, counts = np.unique(PointCloud[:, 0:2], axis=0, return_index=True, return_counts=True) PointCloud_remain = PointCloud[indices] # 剩余点 # !!!!!some important problem is image coordinate is (y,x), not (x,y)调整方向调整这个 y = np.int_(PointCloud_remain[:, 0]) # x axis is -y in LIDAR # y = Discretization - y x = np.int_(PointCloud_remain[:, 1]) # y axis is -x in LIDAR x = Discretization - x # heightMap[y, x] = PointCloud_remain[:, 2] # 高度作为数值 heightMap[x, y] = PointCloud_remain[:, 2] #PointCloud_top = PointCloud[indices] # intensityMap[y, x] = PointCloud_remain[:, 3] # 反射率 intensityMap[x, y] = PointCloud_remain[:, 3] normalizedCounts = np.minimum(1.0, np.log(counts + 1) / np.log(64)) # densityMap[y, x] = normalizedCounts # 用的是出现的次数作为对应坐标的数值 densityMap[x, y] = normalizedCounts # 对三个通道的值进行归一化,后期输出的话可能要×255 densityMap = densityMap / densityMap.max() heightMap = heightMap / heightMap.max() intensityMap = intensityMap / intensityMap.max() # densityMap = 255*densityMap / densityMap.max() # heightMap = 255*heightMap / heightMap.max() # intensityMap = 255*intensityMap / intensityMap.max() RGB_Map = np.zeros((Height, Width, 3)) RGB_Map[:, :, 0] = densityMap # r_map RGB_Map[:, :, 1] = heightMap # g_map RGB_Map[:, :, 2] = intensityMap # b_map save = np.zeros((Discretization, Discretization, 3)) save = RGB_Map[0:Discretization, 0:Discretization, :] # misc.imsave('test_bv.png',save[::-1,::-1,:]) # misc.imsave('test_bv.png',save) return save
from keras.models import load_model from keras.constraints import min_max_norm, non_neg, binary_m, two_value from PIL import Image import os import image_evaluate as ievalue import time import method_module as mm import math dataset = ['stl', 'face'] dataset_cifar = ['cifar'] size = np.zeros(3) size[0] = 32 size[1] = 64 size[2] = 128 size = np.int_(size) size_cifar = np.zeros(1) size_cifar[0] = 32 size_cifar = np.int_(size_cifar) rate = np.arange(10) * 0.1 - 0.1 rate[0] = 0.001 rate[1] = 0.01 print(rate) mf1 = np.zeros((3, 3, 10, 4)) mf2 = np.zeros((3, 3, 10, 4)) mf3 = np.zeros((3, 3, 10, 4)) mf4 = np.zeros((3, 3, 10, 4)) mf5 = np.zeros((3, 3, 10, 4)) mf6 = np.zeros((3, 3, 10, 4)) mf7 = np.zeros((3, 3, 10, 4))
def fkt_pycosmo_2(y, lna, dydlna, k, ha_lna, eta_lna, taudot_lna, lmax, H0, omega_r_0, omega_m_0, omega_k_0, omega_l_0, rh, omega_gam, omega_neu, omega_dm_0, omega_b_0, xc_damp, a_tca): a = np.exp(lna) r_bph_a = 3. / 4. * omega_b_0 / omega_gam * a idx_f = (lna - ha_lna[0]) / (ha_lna[2] - ha_lna[0]) * 2. idx_i = np.floor(idx_f) idx = np.int_(idx_i) ratio = idx_f - idx_i eta = (1 - ratio) * eta_lna[idx] + ratio * eta_lna[idx + 1] ha = (H0 * (omega_r_0 * a**-4 + omega_m_0 * a**-3 + omega_k_0 * a**-2 + omega_l_0)**0.5) / H0 / rh tdot = (1 - ratio) * taudot_lna[idx] + ratio * taudot_lna[idx + 1] psi = -y[0] - 12. / (rh * k * a)**2 * (omega_gam * y[9] + omega_neu * y[6 + 2 * lmax + 3]) dphidlna = psi - k**2 / (3. * a**2 * ha**2) * y[0] + 0.5 / ( ha * rh)**2 * (omega_dm_0 * a**(-3) * y[1] + omega_b_0 * a** (-3) * y[3] + 4. * omega_gam * a**(-4) * y[5] + 4. * omega_neu * a**(-4) * y[6 + 2 * lmax + 1]) ppi = y[9] + y[6] + y[10] n_y = 8 + 3 * lmax dydlna[:] = 0 dydlna[0] = dphidlna dydlna[1] = -k / (a * ha) * y[2] - 3. * dphidlna dydlna[2] = -y[2] + k / (a * ha) * psi dydlna[3] = -k / (a * ha) * y[4] - 3. * dphidlna dydlna[5] = -k / (a * ha) * y[7] - dphidlna dydlna[6] = k / (a * ha) * (-y[8]) + tdot / (a * ha) * (y[6] - ppi / 2.) if a < a_tca: dh_dlna = -1. / (2. * ha) * (4. * omega_r_0 * a**-4 + 3. * omega_m_0 * a**-3 + 2. * omega_k_0 * a**-2) / rh**2 slip = 2. / (1. + r_bph_a) * (y[4] - 3. * y[7]) + 1. / tdot / ( 1 + 1. / r_bph_a) * ((2. * a * ha + a * dh_dlna) * y[4] + k * (2. * y[5] + psi) + k * dydlna[5]) dydlna[4] = -y[4] / (1. + 1. / r_bph_a) + k / (a * ha) * ( (y[5] - 2. * y[9]) / (1. + r_bph_a) + psi) + slip / (1. + r_bph_a) dydlna[7] = k / (3. * a * ha) * ( y[5] - 2. * y[9] + (1. + r_bph_a) * psi) - r_bph_a / 3. * (dydlna[4] + y[4]) dydlna[8] = k / (a * ha) / 3. * (y[6] - 2. * y[10]) + tdot / ( a * ha) * (y[8]) if a >= a_tca: dydlna[4] = -y[4] + k / (a * ha) * psi + tdot / r_bph_a / ( a * ha) * (y[4] - 3. * y[7]) dydlna[7] = k / (3. * a * ha) * (y[5] - 2. * y[9] + psi) + tdot / ( a * ha) * (y[7] - y[4] / 3.) dydlna[8] = k / (a * ha) / 3. * (y[6] - 2. * y[10]) + tdot / ( a * ha) * (y[8]) dydlna[9] = k / (5. * a * ha) * (2. * y[7] - 3. * y[11]) + tdot / ( a * ha) * (y[9] - ppi / 10.) dydlna[10] = k / (a * ha) / 5. * ( 2. * y[8] - 3. * y[12]) + tdot / (a * ha) * (y[10] - ppi / 5.) for i in range(3, lmax): dydlna[5 + 2 * i] = k / (a * ha) / (2. * i + 1.) * ( i * y[5 + 2 * (i - 1)] - (i + 1.) * y[5 + 2 * (i + 1)]) + tdot / (a * ha) * y[5 + 2 * i] dydlna[6 + 2 * i] = k / (a * ha) / (2. * i + 1.) * ( i * y[6 + 2 * (i - 1)] - (i + 1.) * y[6 + 2 * (i + 1)]) + tdot / (a * ha) * y[6 + 2 * i] dydlna[5 + 2 * lmax] = 1. / (a * ha) * (k * y[5 + 2 * (lmax - 1)] - ( (lmax + 1.) / eta - tdot) * y[5 + 2 * lmax]) dydlna[6 + 2 * lmax] = 1. / (a * ha) * (k * y[6 + 2 * (lmax - 1)] - ( (lmax + 1.) / eta - tdot) * y[6 + 2 * lmax]) dydlna[6 + 2 * lmax + 1] = -k / (a * ha) * y[6 + 2 * lmax + 2] - dphidlna dydlna[6 + 2 * lmax + 2] = k / (3. * a * ha) * (y[6 + 2 * lmax + 1] - y[6 + 2 * lmax + 3] + psi) for j in range(2, lmax): dydlna[6 + 2 * lmax + 1 + j] = k / (a * ha) / ( 2. * j + 1.) * (j * y[6 + 2 * lmax + 1 + j - 1] - (j + 1.) * y[6 + 2 * lmax + 1 + j + 1]) dydlna[6 + 2 * lmax + 1 + lmax] = 1. / ( a * ha) * (k * y[6 + 2 * lmax + 1 + lmax - 1] - (lmax + 1.) / eta * y[6 + 2 * lmax + 1 + lmax]) if xc_damp > 0: tanhArg = (k * eta - xc_damp) / 50. tanhA = np.fabs(tanhArg) tanhB = 1.26175667589988239 + tanhA * (-0.54699348440059470 + tanhA * 2.66559097474027817) damping = (1. - tanhB * tanhArg / (tanhB * tanhA + 1)) / 2. dydlna[5:n_y - 1] = dydlna[5:n_y - 1] * damping return dydlna
def clean_windows(X, sfreq, max_bad_chans=0.2, zthresholds=[-3.5, 5], win_len=.5, win_overlap=0.66, min_clean_fraction=0.25, max_dropout_fraction=0.1, show=False): """Remove periods with abnormally high-power content from continuous data. This function cuts segments from the data which contain high-power artifacts. Specifically, only windows are retained which have less than a certain fraction of "bad" channels, where a channel is bad in a window if its power is above or below a given upper/lower threshold (in standard deviations from a robust estimate of the EEG power distribution in the channel). Parameters ---------- X : array, shape=(n_channels, n_samples) Continuous data set, assumed to be appropriately high-passed (e.g. > 1Hz or 0.5Hz - 2.0Hz transition band) max_bad_chans : float The maximum number or fraction of bad channels that a retained window may still contain (more than this and it is removed). Reasonable range is 0.05 (very clean output) to 0.3 (very lax cleaning of only coarse artifacts) (default=0.2). zthresholds : 2-tuple The minimum and maximum standard deviations within which the power of a channel must lie (relative to a robust estimate of the clean EEG power distribution in the channel) for it to be considered "not bad". (default=[-3.5, 5]). The following are detail parameters that usually do not have to be tuned. If you can't get the function to do what you want, you might consider adapting these to your data. win_len : float Window length that is used to check the data for artifact content. This is ideally as long as the expected time scale of the artifacts but not shorter than half a cycle of the high-pass filter that was used. Default: 1. win_overlap : float Window overlap fraction. The fraction of two successive windows that overlaps. Higher overlap ensures that fewer artifact portions are going to be missed, but is slower (default=0.66). max_dropout_fraction : float Maximum fraction that can have dropouts. This is the maximum fraction of time windows that may have arbitrarily low amplitude (e.g., due to the sensors being unplugged) (default=0.1). min_clean_fraction : float Minimum fraction that needs to be clean. This is the minimum fraction of time windows that need to contain essentially uncontaminated EEG. (default=0.25) The following are expert-level parameters that you should not tune unless you fully understand how the method works. truncate_quant : Truncated Gaussian quantile. Quantile range [upper,lower] of the truncated Gaussian distribution that shall be fit to the EEG contents. (default=[0.022, 0.6]) step_sizes : Grid search stepping. Step size of the grid search, in quantiles; separately for [lower,upper] edge of the truncated Gaussian. The lower edge has finer stepping because the clean data density is assumed to be lower there, so small changes in quantile amount to large changes in data space (default=[0.01 0.01]). shape_range : Shape parameter range. Search range for the shape parameter of the generalized Gaussian distribution used to fit clean EEG (default: 1.7:0.15:3.5). Returns ------- clean : array, shape=(n_channels, n_samples) Dataset with bad time periods removed. sample_mask : boolean array, shape=(1, n_samples) Mask of retained samples (logical array). """ assert 0 < max_bad_chans < 1, "max_bad_chans must be a fraction !" truncate_quant = [0.0220, 0.6000] step_sizes = [0.01, 0.01] shape_range = np.linspace(1.7, 3.5, 13) max_bad_chans = np.round(X.shape[0] * max_bad_chans) [nc, ns] = X.shape N = int(win_len * sfreq) offsets = np.int_(np.arange(0, ns - N, np.round(N * (1 - win_overlap)))) logging.debug('[ASR] Determining channel-wise rejection thresholds') wz = np.zeros((nc, len(offsets))) for ichan in range(nc): x = X[ichan, :]**2 Y = [] for o in offsets: Y.append(np.sqrt(np.sum(x[o:o + N]) / N)) mu, sig, alpha, beta = fit_eeg_distribution(Y, min_clean_fraction, max_dropout_fraction, truncate_quant, step_sizes, shape_range) wz[ichan] = (Y - mu) / sig # sort z scores into quantiles wz[np.isnan(wz)] = np.inf # Nan to inf swz = np.sort(wz, axis=0) # determine which windows to remove if np.max(zthresholds) > 0: mask1 = swz[-(np.int(max_bad_chans) + 1), :] > np.max(zthresholds) if np.min(zthresholds) < 0: mask2 = (swz[1 + np.int(max_bad_chans - 1), :] < np.min(zthresholds)) bad_by_mad = mad(wz, c=1, axis=0) < .1 bad_by_std = np.std(wz, axis=0) < .1 mask3 = np.logical_or(bad_by_mad, bad_by_std) remove_mask = np.logical_or.reduce((mask1, mask2, mask3)) removed_wins = np.where(remove_mask) sample_maskidx = [] for i in range(len(removed_wins[0])): if i == 0: sample_maskidx = np.arange(offsets[removed_wins[0][i]], offsets[removed_wins[0][i]] + N) else: sample_maskidx = np.vstack( (sample_maskidx, np.arange(offsets[removed_wins[0][i]], offsets[removed_wins[0][i]] + N))) sample_mask2remove = np.unique(sample_maskidx) clean = np.delete(X, sample_mask2remove, 1) sample_mask = np.ones((1, ns), dtype=bool) if sample_mask2remove.size: sample_mask[0, sample_mask2remove] = False if show: import matplotlib.pyplot as plt f, ax = plt.subplots(nc, sharex=True, figsize=(8, 5)) times = np.arange(ns) / float(sfreq) for i in range(nc): ax[i].fill_between(times, 0, 1, where=sample_mask.flat, transform=ax[i].get_xaxis_transform(), facecolor='none', hatch='...', edgecolor='k', label='selected window') ax[i].plot(times, X[i], lw=.5, label='EEG') ax[i].set_ylim([-50, 50]) # ax[i].set_ylabel(raw.ch_names[i]) ax[i].set_yticks([]) ax[i].set_xlabel('Time (s)') ax[i].set_ylabel(f'ch{i}') ax[0].legend(fontsize='small', bbox_to_anchor=(1.04, 1), borderaxespad=0) plt.subplots_adjust(hspace=0, right=0.75) plt.suptitle('Clean windows') plt.show() return clean, sample_mask
def pipeline(image): #### UNDISTORTING THE IMAGES/FRAMES #### ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None) undist = cv2.undistort( image, mtx, dist, None, mtx ) #using the parameters generated from objpoints and imagepoints to undistort images #### APPLYING THRESHOLDS TO IMAGE/FRAME #### r_thresh = (205, 255) s_thresh = (170, 255) sx_thresh = (20, 100) img = np.copy(undist) hls = cv2.cvtColor(img, cv2.COLOR_RGB2HLS).astype( np.float) #using HLS color space (L-Channel, S-Channel) l_channel = hls[:, :, 1] s_channel = hls[:, :, 2] r_channel = img[:, :, 0] sobelx = cv2.Sobel(l_channel, cv2.CV_64F, 1, 0) #applying sobelx abs_sobelx = np.absolute(sobelx) scaled_sobel = np.uint8(255 * abs_sobelx / np.max(abs_sobelx)) sxbinary = np.zeros_like(scaled_sobel) sxbinary[(scaled_sobel >= sx_thresh[0]) & (scaled_sobel <= sx_thresh[1])] = 1 r_binary = np.zeros_like(r_channel) #using R-Channel for color threshold r_binary[(r_channel >= r_thresh[0]) & (r_channel <= r_thresh[1])] = 1 s_binary = np.zeros_like(s_channel) #using S-Channel for color threshold s_binary[(s_channel >= s_thresh[0]) & (s_channel <= s_thresh[1])] = 1 binary = np.zeros_like(sxbinary) binary[(s_binary == 1) | (sxbinary == 1) | (r_binary == 1)] = 1 #combining the thresholds to one threshold #### APPLYING WARP-FUNCTION ON IMAGE FOR "BIRD-EYE-VIEW" #### src = np.float32([[585, 460], [203, 720], [1127, 720], [705, 460]]) #points on the original image dst = np.float32([[320, 0], [320, 720], [960, 720], [960, 0]]) #destination point on the warped image M = cv2.getPerspectiveTransform(src, dst) #calculate matrix for transformation imshape = image.shape binary_warped1 = cv2.warpPerspective( binary, M, (imshape[1], imshape[0])) #image transformation to bird-eye-view #cv2.line(binary_warped1, (320,0),(320,720), (255,0,0)) #plt.imshow(binary_warped1) #### APPLYING A REGION OF INTEREST ON IMAGE/FRAME TO DISINCLUDE BRIGHT HIGHWAY WALLS AND LIGHT WHEELS #### mask2 = np.zeros_like(binary_warped1) vertices2 = np.array([[(230, imshape[0]), (imshape[1] - 230, imshape[0]), (imshape[1] - 80, 0), (200, 0)]], dtype=np.int32) cv2.fillPoly(mask2, vertices2, 255) binary_warped2 = cv2.bitwise_and( binary_warped1, mask2) #mask areas on the sides of the car mask3 = np.zeros_like(binary_warped1) vertices3 = np.array([[(0, 720), (500, 720), (650, 0), (0, 0)]], dtype=np.int32) cv2.fillPoly(mask3, vertices3, 255) binary_warped3 = cv2.bitwise_and( binary_warped2, mask3 ) #mask area inside lane (experiment to improve challenge video, not neccessary in project video) mask4 = np.zeros_like(binary_warped1) vertices4 = np.array([[(1280, 720), (900, 720), (800, 0), (1280, 0)]], dtype=np.int32) cv2.fillPoly(mask4, vertices4, 255) binary_warped4 = cv2.bitwise_and(binary_warped2, mask4) #again masking inside of the lane binary_warped = np.zeros_like(binary_warped1) binary_warped[(binary_warped3 == 1) | (binary_warped4 == 1)] = 1 #combining both masks to one #### APPLYING HISTOGRAM TO SEARCH FOR PEAKS #### histogram = np.sum(binary_warped[0:720, :], axis=0) #applying histogram out_img = np.dstack((binary_warped, binary_warped, binary_warped)) * 255 midpoint = np.int(histogram.shape[0] / 2) #setting all up for first starting points leftx_base = np.argmax(histogram[:midpoint]) rightx_base = np.argmax(histogram[midpoint:]) + midpoint nwindows = 9 #number of windows window_height = np.int(binary_warped.shape[0] / nwindows) nonzero = binary_warped.nonzero() #identify all white pixels nonzeroy = np.array(nonzero[0]) nonzerox = np.array(nonzero[1]) leftx_current = leftx_base rightx_current = rightx_base margin = 130 #window margin minpix = 50 #minimum pixel to be found to recenter window left_lane_inds = [] right_lane_inds = [] for window in range(nwindows): #step through windows one by one win_y_low = binary_warped.shape[0] - (window + 1) * window_height win_y_high = binary_warped.shape[0] - window * window_height win_xleft_low = leftx_current - margin win_xleft_high = leftx_current + margin win_xright_low = rightx_current - margin win_xright_high = rightx_current + margin cv2.rectangle(out_img, (win_xleft_low, win_y_low), (win_xleft_high, win_y_high), (0, 255, 0), 2) cv2.rectangle(out_img, (win_xright_low, win_y_low), (win_xright_high, win_y_high), (0, 255, 0), 2) good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & (nonzerox >= win_xleft_low) & (nonzerox < win_xleft_high)).nonzero()[0] good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & (nonzerox >= win_xright_low) & (nonzerox < win_xright_high)).nonzero()[0] left_lane_inds.append(good_left_inds) #append good indices right_lane_inds.append(good_right_inds) if len(good_left_inds) > minpix: leftx_current = np.int( np.mean(nonzerox[good_left_inds] )) #recenter window when more pixels found then minpix if len(good_right_inds) > minpix: rightx_current = np.int(np.mean(nonzerox[good_right_inds])) left_lane_inds = np.concatenate(left_lane_inds) right_lane_inds = np.concatenate(right_lane_inds) leftx = nonzerox[left_lane_inds] #extract x and y from found points lefty = nonzeroy[left_lane_inds] rightx = nonzerox[right_lane_inds] righty = nonzeroy[right_lane_inds] left_fit = np.polyfit( lefty, leftx, 2) #set a second order function to left and right points right_fit = np.polyfit(righty, rightx, 2) ploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.shape[0]) left_fitx = left_fit[0] * ploty**2 + left_fit[1] * ploty + left_fit[2] right_fitx = right_fit[0] * ploty**2 + right_fit[1] * ploty + right_fit[2] out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0] out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [0, 0, 255] #plt.imshow(out_img) #plt.plot(left_fitx, ploty, color='yellow') #plt.plot(right_fitx, ploty, color='yellow') #plt.xlim(0, 1280) #plt.ylim(720, 0) #### SEARCHING FOR NEW PEAKS IN DEFINED AREA AROUND THE PREVIOUS LINE POSITION #### nonzero = binary_warped.nonzero( ) #searching for new points in a margin of 80 nonzeroy = np.array(nonzero[0]) nonzerox = np.array(nonzero[1]) margin = 80 left_lane_inds = ( (nonzerox > (left_fit[0] * (nonzeroy**2) + left_fit[1] * nonzeroy + left_fit[2] - margin)) & (nonzerox < (left_fit[0] * (nonzeroy**2) + left_fit[1] * nonzeroy + left_fit[2] + margin))) right_lane_inds = ( (nonzerox > (right_fit[0] * (nonzeroy**2) + right_fit[1] * nonzeroy + right_fit[2] - margin)) & (nonzerox < (right_fit[0] * (nonzeroy**2) + right_fit[1] * nonzeroy + right_fit[2] + margin))) leftx = nonzerox[left_lane_inds] #extract x and y from found points lefty = nonzeroy[left_lane_inds] rightx = nonzerox[right_lane_inds] righty = nonzeroy[right_lane_inds] left_fit = np.polyfit(lefty, leftx, 2) #second order function to left and right points right_fit = np.polyfit(righty, rightx, 2) ploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.shape[0]) #generate values for plotting left_fitx = left_fit[0] * ploty**2 + left_fit[1] * ploty + left_fit[2] right_fitx = right_fit[0] * ploty**2 + right_fit[1] * ploty + right_fit[2] out_img = np.dstack((binary_warped, binary_warped, binary_warped)) * 255 window_img = np.zeros_like(out_img) out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0] out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [0, 0, 255] left_line_window1 = np.array([ np.transpose(np.vstack([left_fitx - margin, ploty])) ]) #generate a polygon to illustrate the search window area left_line_window2 = np.array( [np.flipud(np.transpose(np.vstack([left_fitx + margin, ploty])))]) left_line_pts = np.hstack((left_line_window1, left_line_window2)) right_line_window1 = np.array( [np.transpose(np.vstack([right_fitx - margin, ploty]))]) right_line_window2 = np.array( [np.flipud(np.transpose(np.vstack([right_fitx + margin, ploty])))]) right_line_pts = np.hstack((right_line_window1, right_line_window2)) cv2.fillPoly(window_img, np.int_([left_line_pts]), (0, 255, 0)) #draw the lane onto the warped blank image cv2.fillPoly(window_img, np.int_([right_line_pts]), (0, 255, 0)) result = cv2.addWeighted(out_img, 1, window_img, 0.3, 0) #plt.imshow(result) #plt.plot(left_fitx, ploty, color='yellow') #plt.plot(right_fitx, ploty, color='yellow') #plt.xlim(0, 1280) #plt.ylim(720, 0) #### APPLYING FINAL LINE AND MEASURING LINE CURVATURE #### ploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.shape[0]) leftx = np.array( [left_fit[2] + (y**2) * left_fit[0] + left_fit[1] * y for y in ploty]) rightx = np.array([ right_fit[2] + (y**2) * right_fit[0] + right_fit[1] * y for y in ploty ]) left_fit = np.polyfit(ploty, leftx, 2) #fit a second order polynomial left_fitx = left_fit[0] * ploty**2 + left_fit[1] * ploty + left_fit[2] right_fit = np.polyfit(ploty, rightx, 2) right_fitx = right_fit[0] * ploty**2 + right_fit[1] * ploty + right_fit[2] #mark_size = 3 #plt.plot(leftx, ploty, 'o', color='red', markersize=mark_size) #plt.plot(rightx, ploty, 'o', color='blue', markersize=mark_size) #plt.xlim(0, 1280) #plt.ylim(0, 720) #plt.plot(left_fitx, ploty, color='green', linewidth=3) #plt.plot(right_fitx, ploty, color='green', linewidth=3) #plt.gca().invert_yaxis() y_eval = np.max(ploty) left_curverad = ( (1 + (2 * left_fit[0] * y_eval + left_fit[1])**2)**1.5) / np.absolute( 2 * left_fit[0]) #calculate curvature in pixels right_curverad = ((1 + (2 * right_fit[0] * y_eval + right_fit[1])**2)** 1.5) / np.absolute(2 * right_fit[0]) #print(left_curverad, right_curverad) ym_per_pix = 30 / 720 #convert pixels to meters xm_per_pix = 3.7 / 700 left_fit_cr = np.polyfit(ploty * ym_per_pix, leftx * xm_per_pix, 2) right_fit_cr = np.polyfit(ploty * ym_per_pix, rightx * xm_per_pix, 2) left_curverad = ( (1 + (2 * left_fit_cr[0] * y_eval * ym_per_pix + left_fit_cr[1])**2)** 1.5) / np.absolute(2 * left_fit_cr[0]) #calculate curvature in meters right_curverad = ( (1 + (2 * right_fit_cr[0] * y_eval * ym_per_pix + right_fit_cr[1])**2) **1.5) / np.absolute(2 * right_fit_cr[0]) #print(left_curverad, 'm', right_curverad, 'm') curvature = (float(left_curverad) + float(right_curverad) ) / 2 #calculate mean curvature in meters #### PUTTING ALL BACK TOGETHER AND INVERSE PERSPECTIVE #### warp_zero = np.zeros_like(binary_warped).astype(np.uint8) color_warp = np.dstack((warp_zero, warp_zero, warp_zero)) pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))]) pts_right = np.array( [np.flipud(np.transpose(np.vstack([right_fitx, ploty])))]) pts = np.hstack((pts_left, pts_right)) cv2.fillPoly(color_warp, np.int_([pts]), (0, 255, 0)) Minv = np.linalg.inv(M) #inverse matrix newwarp = cv2.warpPerspective( color_warp, Minv, (image.shape[1], image.shape[0])) #warp the image back to original image space result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0) #output the result #### APPLYING TEXT TO IMAGE/FRAME FOR CURVATURE AND DISTANCE TO LANE CENTER #### font = cv2.FONT_HERSHEY_DUPLEX text = "Radius of Curvature: {} m".format(int(curvature)) #print curvature cv2.putText(result, text, (360, 100), font, 1, (255, 255, 255), 2) pts = np.transpose(np.nonzero((newwarp[:, :, 1]))) center_cam = imshape[1] / 2 try: left_low = np.min( pts[(pts[:, 1] < center_cam) & (pts[:, 0] > 680)][:, 1] ) #taking the farest point away from center on the left side (the lowest x value) right_high = np.max( pts[(pts[:, 1] > center_cam) & (pts[:, 0] > 680)][:, 1] ) #taking the farest point away from center on the right site (the highest x value) center = ( left_low + right_high ) / 2 #taking just points above 680 (near to car), then add them to together and divide by 2 position = ( center_cam - center ) * xm_per_pix #converting values to meters and small if function so that values are always postive if position > 0: text = "Vehicle is {:.2f} m right of center".format(position) else: text = "Vehicle is {:.2f} m left of center".format(-position) cv2.putText(result, text, (360, 150), font, 1, (255, 255, 255), 2) except ValueError: pass #plt.imshow(result, cmap = 'gray') #output the result with text on it #plt.savefig('output_images/test1_out_img3.jpg') #cv2.imwrite('output_images/test1_binary.jpg', binary) return result
def fit_polynomial(binary_warped, isFirstImage): # Grab left_fit & right_fit global left_fit, right_fit # HYPERPARAMETERS # Number of sliding windows nwindows = 9 # Width of the windows +/- margin margin = 100 # Minimum number of pixels found to recenter window minpix = 50 # Identify the x and y positions of all nonzero (i.e. activated) pixels in the image nonzero = binary_warped.nonzero() nonzeroy = np.array(nonzero[0]) nonzerox = np.array(nonzero[1]) # If first image, find lane pixels if (isFirstImage): left_lane_inds, right_lane_inds = find_lane_pixels_initial( binary_warped, nwindows, margin, minpix, nonzero, nonzeroy, nonzerox) # If not first image, search near previous polynomial else: left_lane_inds, right_lane_inds = find_lane_pixels( binary_warped, margin, nonzero, nonzeroy, nonzerox) # Again, extract left and right line pixel positions leftx = nonzerox[left_lane_inds] lefty = nonzeroy[left_lane_inds] rightx = nonzerox[right_lane_inds] righty = nonzeroy[right_lane_inds] # Fit a second order polynomial to each with np.polyfit() # left_fit = np.polyfit(lefty, leftx, 2) right_fit = np.polyfit(righty, rightx, 2) # Generate x and y values for plotting ploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.shape[0]) # Calc both polynomials using ploty, left_fit and right_fit ### left_fitx = left_fit[0] * ploty**2 + left_fit[1] * ploty + left_fit[2] right_fitx = right_fit[0] * ploty**2 + right_fit[1] * ploty + right_fit[2] # Calculate vehicle center offset midpoint = (left_fitx[-1] + right_fitx[-1]) // 2 # veh_pos = img.shape[1]//2 # xm_per_pix = 3.7/680 # dx = (veh_pos - midpoint)*xm_per_pix ## Visualization ## # Create an image to draw on and an image to show the selection window out_img = np.dstack((binary_warped, binary_warped, binary_warped)) * 255 window_img = np.zeros_like(out_img) # Color in left and right line pixels out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0] out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [0, 0, 255] # Generate a polygon to illustrate the search window area # And recast the x and y points into usable format for cv2.fillPoly() left_line_window1 = np.array( [np.transpose(np.vstack([left_fitx - margin, ploty]))]) left_line_window2 = np.array( [np.flipud(np.transpose(np.vstack([left_fitx + margin, ploty])))]) left_line_pts = np.hstack((left_line_window1, left_line_window2)) right_line_window1 = np.array( [np.transpose(np.vstack([right_fitx - margin, ploty]))]) right_line_window2 = np.array( [np.flipud(np.transpose(np.vstack([right_fitx + margin, ploty])))]) right_line_pts = np.hstack((right_line_window1, right_line_window2)) # Draw the lane onto the warped blank image cv2.fillPoly(window_img, np.int_([left_line_pts]), (0, 255, 0)) cv2.fillPoly(window_img, np.int_([right_line_pts]), (0, 255, 0)) result = cv2.addWeighted(out_img, 1, window_img, 0.3, 0) # Draw detected lanes dr_window_img = np.zeros_like(out_img) dr_left_line_pts = np.array( [np.flipud(np.transpose(np.vstack([left_fitx, ploty])))]) dr_right_line_pts = np.array( [np.transpose(np.vstack([right_fitx, ploty]))]) dr_line_pts = np.hstack((dr_left_line_pts, dr_right_line_pts)) cv2.fillPoly(dr_window_img, np.int_([dr_line_pts]), (0, 255, 0)) # Green: Area between two lanes cv2.fillPoly(dr_window_img, np.int_([dr_left_line_pts]), (255, 0, 0)) # Red (RGB): left lane cv2.fillPoly(dr_window_img, np.int_([dr_right_line_pts]), (0, 0, 255)) # Blue (RGB): right lane # Reverse Warp img_lanes = perspective_transform(dr_window_img, rev=True) return result, ploty, midpoint, img_lanes