= 0.5:\r\n return 1\r\n else:\r\n return 0","def predict_bagging_example(x, h_ens):\r\n arr = []\r\n for y in h_ens:\r\n \t# calls predict example repeatedly and stores them in an array\r\n tst_pred = predict_example(x, h_ens[y][1])\r\n arr.append(tst_pred)\r\n # returning the maximum voted\r\n predict_egz = max(set(arr), key=arr.count)\r\n return predict_egz","def from_adaboost(cls, X_train, y_train, data_normalizer_class, n_classifiers):\n\n normalizer = data_normalizer_class().fit(X_train.values)\n X_train = pd.DataFrame(data=normalizer.transform(X_train.values), index=X_train.index, columns=X_train.columns)\n\n rf = AdaBoostClassifier(n_estimators=n_classifiers, algorithm='SAMME') # type: AdaBoostClassifier\n rf = rf.fit(X_train, y_train) # type: AdaBoostClassifier\n\n n_classes = rf.n_classes_\n\n voting_weights = np.empty((n_classifiers, n_classes), dtype=np.float32)\n voting_weights[:] = rf.estimator_weights_[:, np.newaxis]\n\n ensemble = Ensemble(\n X_train=X_train, y_train=y_train,\n data_normalizer_class=normalizer,\n classifiers=rf.estimators_,\n features=np.ones(\n (n_classifiers, X_train.shape[1]), dtype=np.int32\n ),\n activated=np.ones(n_classifiers, dtype=np.int32),\n voting_weights=voting_weights,\n )\n return ensemble","def adaBoost(trainingSamples, weights, featuresSet, classifierCount, threadCount=12, verbose=True):\n #result\n classifiers = []\n classifierWeights = []\n \n for i in range(0, classifierCount):\n if verbose:\n print(\"Training classifier \" + str(i+1) + \"/\" + str(classifierCount) + \"....\")\n\n #normalize weights\n weights = normWeights(weights)\n \n ########## train all classifiers ##########\n #build workers\n workers = []\n for chunk in chunks(featuresSet, threadCount):\n workers.append(Trainer(trainingSamples, weights, chunk))\n\n #run them in a thread pool\n trainedClassifiers = []\n with Pool(processes=threadCount) as pool:\n trainedClassifiers = pool.map(workerRunner, workers)\n trainedClassifiers = getResults(trainedClassifiers)\n\n ########## compute error for each classifier ##########\n #build workers\n workers = []\n for chunk in chunks(trainedClassifiers, threadCount):\n workers.append(ErrorWorker(trainingSamples, weights, chunk))\n \n #run them in a thread pool\n errors = []\n with Pool(processes=threadCount) as pool:\n errors = pool.map(workerRunner, workers)\n errors = getResults(errors)\n\n #choose the classifier with the lowest error\n errors = np.array(errors) \n bestError = errors.min()\n bestClassifierIndex = np.where(errors == errors.min())[0][0]\n bestClassifier = trainedClassifiers[bestClassifierIndex]\n b = bestError/(1-bestError)\n classifiers.append(bestClassifier)\n if verbose:\n print(\"Found feature with error: \" + str(bestError))\n \n #remove used feature from the dataset\n del featuresSet[bestClassifierIndex]\n \n #compute classifier weight\n classifierWeight = np.log(1/b)\n classifierWeights.append(classifierWeight)\n if verbose:\n print(\"Classifier has weight: \" + str(classifierWeight))\n \n #update weights\n for i in range(0, len(weights)):\n weights[i] = weights[i]*np.power(b, 1-bestError)\n\n return classifiers, classifierWeights","def evaluation(self):\n rows_list = []\n for name in self.single_classifier_best.keys():\n row = {}\n row['algorithm'] = name \n row[self.scoring_metric] = self.single_classifier_best[name].best_score_\n rows_list.append(row)\n \n scoring_df = pd.DataFrame(rows_list)\n scoring_sorted = scoring_df.sort_values(self.scoring_metric, ascending=False)\n print()\n print('*'*shutil.get_terminal_size().columns)\n print(scoring_sorted)\n print('*'*shutil.get_terminal_size().columns)\n self.evaluation_scores = scoring_sorted","def lazy_greedy_max(self, budget):\r\n\r\n classes, no_elements = torch.unique(self.y_trn, return_counts=True)\r\n len_unique_elements = no_elements.shape[0]\r\n per_class_bud = int(budget / len(classes))\r\n final_per_class_bud = []\r\n _, sorted_indices = torch.sort(no_elements, descending = True)\r\n\r\n if self.selection_type == 'PerClass':\r\n \r\n total_idxs = 0\r\n for n_element in no_elements:\r\n final_per_class_bud.append(min(per_class_bud, torch.IntTensor.item(n_element)))\r\n total_idxs += min(per_class_bud, torch.IntTensor.item(n_element))\r\n \r\n if total_idxs < budget:\r\n bud_difference = budget - total_idxs\r\n for i in range(len_unique_elements):\r\n available_idxs = torch.IntTensor.item(no_elements[sorted_indices[i]])-per_class_bud \r\n final_per_class_bud[sorted_indices[i]] += min(bud_difference, available_idxs)\r\n total_idxs += min(bud_difference, available_idxs)\r\n bud_difference = budget - total_idxs\r\n if bud_difference == 0:\r\n break\r\n\r\n total_greedy_list = []\r\n for i in range(len_unique_elements):\r\n idxs = torch.where(self.y_trn == classes[i])[0]\r\n \r\n if self.submod == 'facility_location':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.facilityLocation.FacilityLocationSelection(random_state=0, metric='precomputed',\r\n n_samples=final_per_class_bud[i])\r\n elif self.submod == 'graph_cut':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.graphCut.GraphCutSelection(random_state=0, metric='precomputed',\r\n n_samples=final_per_class_bud[i])\r\n elif self.submod == 'saturated_coverage':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.saturatedCoverage.SaturatedCoverageSelection(random_state=0, metric='precomputed',\r\n n_samples=final_per_class_bud[i])\r\n elif self.submod == 'sum_redundancy':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.sumRedundancy.SumRedundancySelection(random_state=0, metric='precomputed',\r\n n_samples=final_per_class_bud[i])\r\n elif self.submod == 'feature_based':\r\n fl = apricot.functions.featureBased.FeatureBasedSelection(random_state=0, n_samples=final_per_class_bud[i])\r\n\r\n if self.submod == 'feature_based':\r\n\r\n x_sub = fl.fit_transform(self.x_trn[idxs].numpy())\r\n greedyList = self.get_index(self.x_trn[idxs].numpy(), x_sub)\r\n total_greedy_list.extend(idxs[greedyList])\r\n\r\n else: \r\n\r\n sim_sub = fl.fit_transform(self.dist_mat.cpu().numpy())\r\n greedyList = list(np.argmax(sim_sub, axis=1))\r\n total_greedy_list.extend(idxs[greedyList])\r\n\r\n elif self.selection_type == 'Supervised':\r\n \r\n \r\n if self.submod == 'feature_based':\r\n \r\n class_map = {}\r\n for i in range(len_unique_elements):\r\n class_map[torch.IntTensor.item(classes[i])] = i #Mapping classes from 0 to n\r\n \r\n sparse_data = torch.zeros([self.x_trn.shape[0], self.x_trn.shape[1]*len_unique_elements])\r\n for i in range(self.x_trn.shape[0]):\r\n \r\n start_col = class_map[torch.IntTensor.item(self.y_trn[i])]*self.x_trn.shape[1]\r\n end_col = start_col+self.x_trn.shape[1]\r\n sparse_data[i, start_col:end_col] = self.x_trn[i, :]\r\n\r\n fl = apricot.functions.featureBased.FeatureBasedSelection(random_state=0, n_samples=budget)\r\n x_sub = fl.fit_transform(sparse_data.numpy())\r\n total_greedy_list = self.get_index(sparse_data.numpy(), x_sub)\r\n\r\n else:\r\n for i in range(len(classes)):\r\n \r\n if i == 0:\r\n idxs = torch.where(self.y_trn == classes[i])[0]\r\n N = len(idxs)\r\n self.compute_score(idxs)\r\n row = idxs.repeat_interleave(N)\r\n col = idxs.repeat(N)\r\n data = self.dist_mat.cpu().numpy().flatten()\r\n else:\r\n idxs = torch.where(self.y_trn == classes[i])[0]\r\n N = len(idxs)\r\n self.compute_score(idxs)\r\n row = torch.cat((row, idxs.repeat_interleave(N)), dim=0)\r\n col = torch.cat((col, idxs.repeat(N)), dim=0)\r\n data = np.concatenate([data, self.dist_mat.cpu().numpy().flatten()], axis=0)\r\n \r\n \r\n sparse_simmat = csr_matrix((data, (row.numpy(), col.numpy())), shape=(self.N_trn, self.N_trn))\r\n #self.dist_mat = sparse_simmat\r\n\r\n if self.submod == 'facility_location':\r\n fl = apricot.functions.facilityLocation.FacilityLocationSelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'graph_cut':\r\n fl = apricot.functions.graphCut.GraphCutSelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'saturated_coverage':\r\n fl = apricot.functions.saturatedCoverage.SaturatedCoverageSelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'sum_redundancy':\r\n fl = apricot.functions.sumRedundancy.SumRedundancySelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n sim_sub = fl.fit_transform(sparse_simmat)\r\n total_greedy_list = list(np.array(np.argmax(sim_sub, axis=1)).reshape(-1))\r\n\r\n\r\n if self.selection_type == 'Full':\r\n \r\n\r\n total_greedy_list = []\r\n idx_end = self.x_trn.shape[0] - 1\r\n idxs = torch.linspace(0, idx_end, self.x_trn.shape[0]).long()\r\n\r\n if self.submod == 'facility_location':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.facilityLocation.FacilityLocationSelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'graph_cut':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.graphCut.GraphCutSelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'saturated_coverage':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.saturatedCoverage.SaturatedCoverageSelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'sum_redundancy':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.sumRedundancy.SumRedundancySelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'feature_based':\r\n fl = apricot.functions.featureBased.FeatureBasedSelection(random_state=0, n_samples=budget)\r\n\r\n if self.submod == 'feature_based':\r\n\r\n x_sub = fl.fit_transform(self.x_trn.numpy())\r\n total_greedy_list = self.get_index(self.x_trn.numpy(), x_sub)\r\n\r\n else: \r\n\r\n sim_sub = fl.fit_transform(self.dist_mat.cpu().numpy())\r\n total_greedy_list = list(np.argmax(sim_sub, axis=1))\r\n\r\n return total_greedy_list","def collect_best_features(self):\n bincsp = self.binary_csp # just to make code shorter\n n_folds = len(self.binary_csp.folds)\n n_class_pairs = len(self.binary_csp.class_pairs)\n result_shape = (n_folds, n_class_pairs)\n self.train_feature = np.empty(result_shape, dtype=object)\n self.train_feature_full_fold = np.empty(result_shape, dtype=object)\n self.test_feature = np.empty(result_shape, dtype=object)\n self.test_feature_full_fold = np.empty(result_shape, dtype=object)\n self.selected_filters_per_filterband = np.empty(result_shape, dtype=object)\n for fold_i in range(n_folds):\n for class_pair_i in range(n_class_pairs):\n bin_csp_train_features = deepcopy(bincsp.train_feature[\n self.selected_filter_inds, fold_i, class_pair_i])\n bin_csp_train_features_full_fold = deepcopy(\n bincsp.train_feature_full_fold[\n self.selected_filter_inds,\n fold_i, class_pair_i])\n bin_csp_test_features = deepcopy(bincsp.test_feature[\n self.selected_filter_inds, fold_i, class_pair_i])\n bin_csp_test_features_full_fold = deepcopy(\n bincsp.test_feature_full_fold[\n self.selected_filter_inds,fold_i, class_pair_i])\n selected_filters_per_filt = self.select_best_filters_best_filterbands(\n bin_csp_train_features, max_features=self.n_features,\n forward_steps=self.forward_steps, \n backward_steps=self.backward_steps,\n stop_when_no_improvement=self.stop_when_no_improvement)\n self.train_feature[fold_i, class_pair_i] = \\\n self.collect_features_for_filter_selection(\n bin_csp_train_features, selected_filters_per_filt)\n self.train_feature_full_fold[fold_i, class_pair_i] = \\\n self.collect_features_for_filter_selection(\n bin_csp_train_features_full_fold, selected_filters_per_filt)\n \n self.test_feature[fold_i, class_pair_i] = \\\n self.collect_features_for_filter_selection(\n bin_csp_test_features, selected_filters_per_filt)\n self.test_feature_full_fold[fold_i, class_pair_i] = \\\n self.collect_features_for_filter_selection(\n bin_csp_test_features_full_fold, selected_filters_per_filt)\n \n self.selected_filters_per_filterband[fold_i, class_pair_i] = \\\n selected_filters_per_filt","def get_optimal_rounds(dtrain, param):\n num_round = 1000\n bst = xgb.cv(param, dtrain, num_round, nfold=10,\n metrics={'logloss', 'auc'}, seed=0,\n callbacks=[xgb.callback.print_evaluation(show_stdv=True),\n xgb.callback.early_stop(10)])\n return len(bst)-1","def ensemble_accuracy(n_classifiers, accuracy):\n k_start = int(math.ceil(n_classifiers / 2.0))\n probs = [comb(n_classifiers, k) *\n accuracy**k *\n (1 - accuracy)**(n_classifiers - k)\n for k in range(k_start, n_classifiers + 1)]\n return sum(probs)","def try_ada_boost_decision_tree():\n\n print(\"AdaBoost to Decision Tree\")\n from sklearn.tree import DecisionTreeClassifier\n from sklearn.ensemble import AdaBoostClassifier\n from sklearn.grid_search import GridSearchCV\n\n param_grid = {\"base_estimator__criterion\" : [\"gini\", \"entropy\"],\n \"base_estimator__splitter\" : [\"best\", \"random\"],\n \"n_estimators\": [10, 30]\n }\n\n DTC = DecisionTreeClassifier(random_state = 11, max_features = \"auto\", class_weight = \"balanced\",max_depth = None)\n\n ABC = AdaBoostClassifier(base_estimator = DTC)\n\n grid_search_ABC = GridSearchCV(ABC, param_grid=param_grid, scoring = 'roc_auc')\n\n grid_search_ABC.fit(features_train,labels_train)\n\n pred = grid_search_ABC.predict(features_test)\n accuracy = accuracy_score(labels_test, pred)\n precision = precision_score(labels_test, pred)\n recall = recall_score(labels_test, pred)\n\n print(\"DecisionTree after applying AdaBoost and GridSearchCV:\")\n print(\"accuracy AdaBoost: \", accuracy)\n print(\"precision: \", precision)\n print(\"recall: \", recall)\n print_separator_line()\n dict_results = { \"classifier\": \"AdaBoost decision tree\", \"accuracy\": accuracy, \"precision\": precision, \"recall\": recall }\n return dict_results, grid_search_ABC","def classify(self, data):\n guesses = []\n for datum in data:\n vectors = util.Counter()\n for l in self.legalLabels:\n vectors[l] = self.weights[l] * datum + self.bias[l]\n guesses.append(vectors.argMax())\n return guesses","def ensembleVote(x, classes, ensemble):\n votes = np.array([0 for kk in range(len(classes))])\n for i in ensemble:\n votes = votes + classProbs(x, ensemble[i][\"tree\"], classes)\n maxVote = 0\n loc = None\n for ind, vote in enumerate(votes):\n if vote > maxVote:\n maxVote = vote\n loc = ind\n prediction = classes[loc]\n return prediction","def classify(self, data ):\n guesses = []\n for datum in data:\n vectors = util.Counter()\n for l in self.legalLabels:\n vectors[l] = self.weights[l] * datum\n guesses.append(vectors.argMax())\n return guesses","def main(keep_best_count, mutation_factor, rounds, target, stagnate):\n ways = [range(len(DISTANCES))]\n result = {'round':0,'cost':None}\n for i in range(rounds):\n ways = mutate(ways,mutation_factor)\n best = []\n for way in ways:\n best.append((rate(way),way))\n best.sort()\n if VERBOSITY:\n for way in best:\n print way\n print \"Round %d best way is %s\" % (i+1, best[0][0])\n # break if we hit the target\n if best[0][0] <= target:\n print \"Hit Target\"\n break\n # break if we stagnate to long\n if result['cost'] is None or best[0][0] <result['cost']:\n result['cost'] = best[0][0]\n result['round'] = i+1\n elif result['round'] + stagnate <= i+1:\n print \"Stagnate to long\"\n break\n ways = list(b[1] for b in best[0:keep_best_count])\n print \"\"\n print \"best found order with cost=%d\" % best[0][0]\n print ' '.join(list(NAMES[i] for i in best[0][1]))\n print \"\"","def __call__(self, clfs, dataset):\n if len(clfs)==0:\n return [] # to don't even bother\n\n all_label_counts = None\n for clf in clfs:\n # Lets check first if necessary conditional attribute is enabled\n if not clf.ca.is_enabled(\"predictions\"):\n raise ValueError, \"MaximalVote needs classifiers (such as \" + \\\n \"%s) with state 'predictions' enabled\" % clf\n predictions = clf.ca.predictions\n if all_label_counts is None:\n all_label_counts = [ {} for i in xrange(len(predictions)) ]\n\n # for every sample\n for i in xrange(len(predictions)):\n prediction = predictions[i]\n # XXX fishy location due to literal labels,\n # TODO simplify assumptions and logic\n if isinstance(prediction, basestring) or \\\n not is_sequence_type(prediction):\n prediction = (prediction,)\n for label in prediction: # for every label\n # XXX we might have multiple labels assigned\n # but might not -- don't remember now\n if not label in all_label_counts[i]:\n all_label_counts[i][label] = 0\n all_label_counts[i][label] += 1\n\n predictions = []\n # select maximal vote now for each sample\n for i in xrange(len(all_label_counts)):\n label_counts = all_label_counts[i]\n # lets do explicit search for max so we know\n # if it is unique\n maxk = [] # labels of elements with max vote\n maxv = -1\n for k, v in label_counts.iteritems():\n if v > maxv:\n maxk = [k]\n maxv = v\n elif v == maxv:\n maxk.append(k)\n\n assert len(maxk) >= 1, \\\n \"We should have obtained at least a single key of max label\"\n\n if len(maxk) > 1:\n warning(\"We got multiple labels %s which have the \" % maxk +\n \"same maximal vote %d. XXX disambiguate. \" % maxv +\n \"Meanwhile selecting the first in sorted order\")\n predictions.append(sorted(maxk)[0])\n\n ca = self.ca\n ca.estimates = all_label_counts\n ca.predictions = predictions\n return predictions","def classify(X, Y, skf, clf, round_threshold=0.5, average=\"macro\"):\n X = X.values\n if isinstance(Y, pd.Series):\n labels = [\"{}_0\".format(Y.name), \"{}_1\".format(Y.name)]\n Y = np.ravel(Y)\n else:\n Y, labels = Y.values, list(Y.columns)\n\n fold_results = []\n for train, test in skf.split(X, Y):\n current_clf = clone(clf)\n X_train, X_test, Y_train, Y_test = X[train], X[test], Y[train], Y[test]\n\n current_clf.fit(X_train, Y_train)\n Y_prob = current_clf.predict_proba(X_test)\n Y_pred = current_clf.predict(X_test)\n\n (p, r, f1, auc, jac, hl, p_c,\n r_c, f1_c, s_c) = calculate_metrics(Y_test, Y_pred, Y_prob, average)\n\n # calculate overall scores for current fold\n fold_scores = {\n \"precision\": p,\n \"recall\": r,\n \"f1\": f1,\n \"auc\": auc,\n \"jaccard\": jac,\n \"hamming_loss\": hl\n }\n\n for i in range(len(labels)):\n fold_scores[\"precision_{0}\".format(labels[i])] = p_c[i]\n fold_scores[\"recall_{0}\".format(labels[i])] = r_c[i]\n fold_scores[\"f1_{0}\".format(labels[i])] = f1_c[i]\n fold_scores[\"support_{0}\".format(labels[i])] = s_c[i]\n\n fold_results.append({\n \"scores\": fold_scores,\n \"y_pred\": Y_pred,\n \"y_prob\": Y_prob,\n \"y_test\": Y_test\n })\n\n scores = {}\n for score in fold_results[0][\"scores\"].keys():\n values = [s[\"scores\"][score] for s in fold_results]\n scores[score] = (np.sum(values) if score.startswith(\"support_\")\n else np.mean(values))\n\n return scores, fold_results","def classify(self, data):\n guesses = []\n for datum in data:\n vectors = util.Counter()\n for l in self.legalLabels:\n vectors[l] = self.weights[l] * datum\n guesses.append(vectors.argMax())\n return guesses","def classify(self, testData):\n\tguesses = []\n\tself.posteriors = [] # Log posteriors are stored for later data analysis (autograder).\n\tfor datum in testData:\n\t posterior = self.calculateLogJointProbabilities(datum)\n\t guesses.append(posterior.argMax())\n\t self.posteriors.append(posterior)\n\treturn guesses","def fit(self, X, y):\n X_array=np.asarray(X) \n X_data_int=X_array[:,0:X_array.shape[1]-1]\n X_data= X_data_int/1.0\n \n p=1\n number_of_p=int(X_data.shape[0]*p)\n l = range(0,X_data.shape[0])\n randlist = random.sample(l, number_of_p) \n \n for i in randlist:\n y[i]=y[i]*(-1)\n\n sample_weight2 = np.empty(X_data.shape[0], dtype=np.float)\n sample_weight2[:] = 1. / X_data.shape[0]\n self.estimators_ = []\n\n\n self.estimator_errors_ = np.ones(self.iters, dtype=np.float)\n \n #classfier=CLASSIFIERS[self.algorithm]()\n \n for iboost in range(self.iters):\n # Boosting step\n classfier=CLASSIFIERS[self.algorithm]() \n sample_weight3=[]\n sample_weight3=sample_weight2\n classfier.fit(X_data, y,sample_weight3)\n y_predict = classfier.predict(X_data)\n \n # Instances incorrectly classified\n incorrect = y_predict != y\n\n # Error fraction\n \n estimator_error = np.mean(np.average(incorrect, weights=sample_weight2, axis=0))\n #estimator_error = np.sum(np.average(incorrect, weights=sample_weight2, axis=0))\n \n # Stop if classification is perfect\n if estimator_error <= 0:\n estimator_weight = 1.\n estimator_error = 0.\n \n # Stop if the error is at least as bad as random guessing\n if estimator_error >= 1. - (1. / 2):\n raise ValueError('BaseClassifier in AdaBoostClassifier '\n 'ensemble is worse than random, ensemble '\n 'can not be fit.')\n break\n\n #estimator_weight = 1./2*np.log((1. - estimator_error) / estimator_error)\n estimator_weight = np.log((1. - estimator_error) / estimator_error)\n # Only boost the weights if I will fit again\n if not iboost == self.iters - 1:\n # Only boost positive weights\n sample_weight2 *= np.exp(estimator_weight * incorrect * ((sample_weight2 > 0) | (estimator_weight < 0)))\n\n # Early termination\n if sample_weight2 is None:\n break\n\n self.estimator_weights_[iboost] = estimator_weight\n self.estimator_errors_[iboost] = estimator_error\n\n # Stop if error is zero\n if estimator_error == 0:\n break\n\n sample_weight_sum = np.sum(sample_weight2)\n \n\n # Stop if the sum of sample weights has become non-positive\n if sample_weight_sum <= 0:\n break\n\n if iboost < self.iters - 1:\n # Normalize\n sample_weight2 /= sample_weight_sum\n \n self.estimators_.append(classfier)\n\n return self","def naive_bayes_classify(df: pd.DataFrame, vect, names):\n features = vect\n target = df.success_lvl\n\n X_train, X_test, y_train, y_test = \\\n train_test_split(features, target, test_size=0.2, random_state=42)\n\n nb_clf = MultinomialNB()\n nb_clf.fit(X_train, y_train)\n nb_predictions = nb_clf.predict(X_test)\n print('Accuracy score for Naive Bayes:', accuracy_score(y_test, nb_predictions))\n\n\n # Find Top/Bottom num of terms used to describe the classes.\n num = 10\n low_class_prob_sorted = nb_clf.feature_log_prob_[0, :].argsort()[::-1]\n hi_class_prob_sorted = nb_clf.feature_log_prob_[1, :].argsort()[::-1]\n print('\\n', f'Low score Top{num} phrases:', np.take(names, low_class_prob_sorted[:num]))\n print('\\n', f'Low score Bot{num} phrases:', np.take(names, low_class_prob_sorted[-num:]))\n print('\\n', f'High score Top{num} phrases:', np.take(names, hi_class_prob_sorted[:num]))\n print('\\n', f'High score Bot{num} phrases:', np.take(names, hi_class_prob_sorted[-num:]))","def borda(election, tiebreaker=None):\n election = np.asarray(election)\n\n ncands = election.shape[1]\n total_tally = np.zeros(ncands, dtype=int)\n\n # Tally candidates in each column, multiply by points for each rank level\n for n, column in enumerate(election.T):\n tally = np.bincount(column, minlength=ncands)\n total_tally += (ncands - n)*tally\n\n # Python lists are faster than NumPy here\n total_tally = total_tally.tolist()\n\n # Find the set of candidates who have the highest score (usually only one)\n highest = max(total_tally)\n winners = _all_indices(total_tally, highest)\n\n # Break any ties using specified method\n tiebreak = _get_tiebreak(tiebreaker, _tiebreak_map)\n return tiebreak(winners)[0]","def tune_learning_algo(data_X, data_y, params_set, algo_factory, folds=5):\n accuracy_for_params = {}\n best_accuracy = 0.0\n best_params = None\n\n # For all the available parameters, do a k-fold evaluation to get average accuracy.\n # Report the params with best accuracy.\n for params in params_set:\n # Do a k fold training and evaluation for this params and get average accuracy.\n accuracy = train_and_evaluate_k_fold(data_X, data_y, params, algo_factory, folds)\n # Save\n accuracy_for_params[params] = accuracy\n # Update the best parameters till now.\n if accuracy > best_accuracy:\n best_params = params\n best_accuracy = accuracy\n # Return.\n return accuracy_for_params, best_params","def classify(self, data ):\n\t\tguesses = []\n\t\tfor datum in data:\n\t\t\tvectors = util.Counter()\n\t\t\tfor l in self.legalLabels:\n\t\t\t\tvectors[l] = self.weights[l] * datum\n\t\t\tguesses.append(vectors.argMax())\n\t\treturn guesses","def classify(self, data ):\n\t\tguesses = []\n\t\tfor datum in data:\n\t\t\tvectors = util.Counter()\n\t\t\tfor l in self.legalLabels:\n\t\t\t\tvectors[l] = self.weights[l] * datum\n\t\t\tguesses.append(vectors.argMax())\n\t\treturn guesses","def classify(self, testData):\n guesses = []\n self.posteriors = [] # Log posteriors are stored for later data analysis (autograder).\n for datum in testData:\n posterior = self.calculateLogJointProbabilities(datum)\n guesses.append(posterior.argMax())\n self.posteriors.append(posterior)\n return guesses","def classify(self, testData):\n guesses = []\n self.posteriors = [] # Log posteriors are stored for later data analysis (autograder).\n for datum in testData:\n posterior = self.calculateLogJointProbabilities(datum)\n guesses.append(posterior.argMax())\n self.posteriors.append(posterior)\n return guesses","def get_bests(self):\n set_names = [\"training\", \"hp_selection\", \"validation\"]\n run_tec_conf_set = recursivedict()\n validation = self._campaign_configuration['General']['validation']\n hp_selection = self._campaign_configuration['General']['hp_selection']\n if (validation, hp_selection) in {(\"All\", \"All\"), (\"Extrapolation\", \"All\"), (\"All\", \"HoldOut\"), (\"HoldOut\", \"All\"), (\"HoldOut\", \"HoldOut\"), (\"Extrapolation\", \"HoldOut\")}:\n # For each run, for each technique the best configuration\n run_tec_best_conf = recursivedict()\n\n # Hyperparameter search\n for conf in self._exp_confs:\n run = int(conf.get_signature()[0].replace(\"run_\", \"\"))\n technique = conf.technique\n run_tec_conf_set[run][technique][str(conf.get_signature()[4:])] = conf.mapes\n # First experiment for this technique or better than the current best\n if technique not in run_tec_best_conf[run] or conf.mapes[\"hp_selection\"] < run_tec_best_conf[run][technique].mapes[\"hp_selection\"]:\n run_tec_best_conf[run][technique] = conf\n\n # Print results for each run\n for run in range(0, self._campaign_configuration['General']['run_num']):\n self._logger.info(\"-->Printing results for run %s\", str(run))\n overall_run_best = None\n # Print data of single techniques\n for technique in run_tec_best_conf[run]:\n temp = run_tec_best_conf[run][technique]\n self._logger.info(\"---Best result for %s - Configuration is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", technique, temp.get_signature()[4:], temp.mapes[\"training\"], temp.mapes[\"hp_selection\"], temp.mapes[\"validation\"])\n\n # Compute which is the best technique\n if not overall_run_best or temp.mapes[\"hp_selection\"] < overall_run_best.mapes[\"hp_selection\"]:\n overall_run_best = temp\n best_model_description = overall_run_best.print_model()\n self._logger.info(\"<--Overall best result is %s %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", overall_run_best.get_signature()[3:], \"(\" + best_model_description + \")\" if best_model_description else \"\", overall_run_best.mapes[\"training\"], overall_run_best.mapes[\"hp_selection\"], overall_run_best.mapes[\"validation\"])\n\n elif (validation, hp_selection) in {(\"KFold\", \"All\"), (\"KFold\", \"HoldOut\")}:\n folds = float(self._campaign_configuration['General']['folds'])\n # For each run, for each fold, for each technique, the best configuration\n run_fold_tec_best_conf = recursivedict()\n\n # Hyperparameter search inside each fold\n for conf in self._exp_confs:\n run = int(conf.get_signature()[0].replace(\"run_\", \"\"))\n fold = int(conf.get_signature()[1].replace(\"f\", \"\"))\n technique = conf.technique\n if \"hp_selection\" not in run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])]:\n for set_name in set_names:\n run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])][set_name] = 0\n for set_name in set_names:\n run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])][set_name] = run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])][set_name] + conf.mapes[set_name] / folds\n # First experiment for this fold+technique or better than the current best\n if technique not in run_fold_tec_best_conf[run][fold] or conf.mapes[\"hp_selection\"] < run_fold_tec_best_conf[run][fold][technique].mapes[\"hp_selection\"]:\n run_fold_tec_best_conf[run][fold][technique] = conf\n\n # Aggregate different folds (only the value of the mapes)\n run_tec_set = recursivedict()\n for run in run_fold_tec_best_conf:\n for fold in run_fold_tec_best_conf[run]:\n for tec in run_fold_tec_best_conf[run][fold]:\n if \"hp_selection\" not in run_tec_set[run][technique]:\n for set_name in set_names:\n run_tec_set[run][tec][set_name] = 0\n for set_name in set_names:\n run_tec_set[run][tec][set_name] = run_fold_tec_best_conf[run][fold][tec].mapes[set_name]\n # Print results for each run\n for run in range(0, self._campaign_configuration['General']['run_num']):\n self._logger.info(\"Printing results for run %s\", str(run))\n overall_run_best = ()\n # Print data of single techniques\n for technique in run_tec_set[run]:\n self._logger.info(\"---Best result for %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", technique, run_tec_set[run][technique][\"training\"], run_tec_set[run][technique][\"hp_selection\"], run_tec_set[run][technique][\"validation\"])\n\n # Compute which is the best technique\n if not overall_run_best or run_tec_set[run][technique][\"hp_selection\"] < overall_run_best[1][\"hp_selection\"]:\n overall_run_best = (technique, run_tec_set[run][technique])\n\n self._logger.info(\"---Overall best result is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", overall_run_best[0], overall_run_best[1][\"training\"], overall_run_best[1][\"hp_selection\"], overall_run_best[1][\"validation\"])\n\n # Overall best will contain as first argument the technique with the best (across runs) average (across folds) mape on validation; now we consider on all the runs and on all the folds the configuraiton of this technique with best validation mape\n\n elif (validation, hp_selection) in {(\"All\", \"KFold\"), (\"HoldOut\", \"KFold\"), (\"Extrapolation\", \"KFold\")}:\n folds = float(self._campaign_configuration['General']['folds'])\n # For each run, for each technique, for each configuration, the aggregated mape\n run_tec_conf_set = recursivedict()\n\n # Hyperparameter search aggregating over folders\n for conf in self._exp_confs:\n run = int(conf.get_signature()[0].replace(\"run_\", \"\"))\n fold = int(conf.get_signature()[2].replace(\"f\", \"\"))\n technique = conf.technique\n configuration = str(conf.get_signature()[4:])\n if \"hp_selection\" not in run_tec_conf_set[run][technique][configuration]:\n for set_name in set_names:\n run_tec_conf_set[run][technique][configuration][set_name] = 0\n for set_name in set_names:\n run_tec_conf_set[run][technique][configuration][set_name] = run_tec_conf_set[run][technique][configuration][set_name] + conf.mapes[set_name] / folds\n\n # Select the best configuration for each technique across different folders\n run_tec_best_conf = recursivedict()\n for run in run_tec_conf_set:\n for tec in run_tec_conf_set[run]:\n for conf in run_tec_conf_set[run][tec]:\n if tec not in run_tec_best_conf[run] or run_tec_conf_set[run][tec][conf][\"hp_selection\"] < run_tec_best_conf[run][tec][1][\"hp_selection\"]:\n run_tec_best_conf[run][tec] = (conf, run_tec_conf_set[run][tec][conf])\n\n # Print results for each run\n for run in range(0, self._campaign_configuration['General']['run_num']):\n self._logger.info(\"Printing results for run %s\", run)\n overall_run_best = () # (technique, configuration, mapes)\n # Print data of single techniques\n for technique in run_tec_best_conf[run]:\n temp = run_tec_best_conf[run][technique]\n self._logger.info(\"---Best result for %s - Configuration is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", technique, temp[0], temp[1][\"training\"], temp[1][\"hp_selection\"], temp[1][\"validation\"])\n\n # Compute which is the best technique\n if not overall_run_best or temp[1][\"hp_selection\"] < overall_run_best[2][\"hp_selection\"]:\n overall_run_best = (technique, temp[0], temp[1])\n\n self._logger.info(\"---Overall best result is %s %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", overall_run_best[0], overall_run_best[1], overall_run_best[2][\"training\"], overall_run_best[2][\"hp_selection\"], overall_run_best[2][\"validation\"])\n\n elif (validation, hp_selection) in {(\"KFold\", \"KFold\")}:\n folds = float(self._campaign_configuration['General']['folds'])\n # For each run, for each external fold, for each technique, the aggregated mape\n run_efold_tec_conf_set = recursivedict()\n\n # Hyperparameter search aggregating over internal folders\n for conf in self._exp_confs:\n run = int(conf.get_signature()[0].replace(\"run_\", \"\"))\n ext_fold = int(conf.get_signature()[2].replace(\"f\", \"\"))\n technique = conf.technique\n configuration = str(conf.get_signature()[4:])\n if \"hp_selection\" not in run_tec_conf_set[run][technique][configuration]:\n for set_name in set_names:\n run_tec_conf_set[run][technique][configuration][set_name] = 0\n for set_name in set_names:\n run_tec_conf_set[run][technique][configuration][set_name] = run_tec_conf_set[run][technique][configuration][set_name] + (conf.mapes[set_name] / (folds * folds))\n if configuration not in run_efold_tec_conf_set[run][ext_fold][technique]:\n for set_name in set_names:\n run_efold_tec_conf_set[run][ext_fold][technique][configuration][set_name] = 0\n for set_name in set_names:\n run_efold_tec_conf_set[run][ext_fold][technique][configuration][set_name] = run_efold_tec_conf_set[run][ext_fold][technique][configuration][set_name] + (conf.mapes[set_name] / (folds * folds))\n\n # Select the best configuration for each technique in each external fold across different internal folders\n run_efold_tec_best_conf = recursivedict()\n for run in run_efold_tec_conf_set:\n for efold in run_efold_tec_conf_set[run]:\n for tec in run_efold_tec_conf_set[run][efold]:\n for conf in run_efold_tec_conf_set[run][efold][tec]:\n if conf not in run_efold_tec_best_conf[run][efold][tec] or run_efold_tec_conf_set[run][efold][tec][conf][\"hp_selection\"] < run_efold_tec_best_conf[run][efold][tec][1][\"hp_selection\"]:\n run_efold_tec_best_conf[run][efold][tec] = (conf, run_efold_tec_conf_set[run][efold][tec][conf], run_efold_tec_conf_set[run][efold][tec][conf])\n\n # Aggregate on external folds\n run_tec_set = recursivedict()\n for run in run_efold_tec_best_conf:\n for efold in run_efold_tec_best_conf[run]:\n for tec in run_efold_tec_best_conf[run][efold]:\n if \"hp_selection\" not in run_tec_set[run][tec]:\n for set_name in set_names:\n run_tec_set[run][tec][set_name] = 0\n for set_name in set_names:\n run_tec_set[run][tec][set_name] = run_tec_set[run][tec][set_name] + run_efold_tec_best_conf[run][efold][tec][1][set_name]\n\n # Print results for each run\n for run in range(0, self._campaign_configuration['General']['run_num']):\n self._logger.info(\"Printing results for run %s\", run)\n overall_run_best = ()\n # Print data of single techniques\n for technique in run_tec_set[run]:\n self._logger.info(\"---Best result for %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", technique, run_tec_set[run][technique][\"training\"], run_tec_set[run][technique][\"hp_selection\"], run_tec_set[run][technique][\"validation\"])\n\n # Compute which is the best technique\n if not overall_run_best or run_tec_set[run][technique][\"hp_selection\"] < overall_run_best[1][\"hp_selection\"]:\n overall_run_best = (technique, run_tec_set[run][technique])\n\n self._logger.info(\"---Overall best result is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\", overall_run_best[0], overall_run_best[1][\"training\"], overall_run_best[1][\"hp_selection\"], overall_run_best[1][\"validation\"])\n\n else:\n self._logger.error(\"Unexpected combination: %s\", str((validation, hp_selection)))\n sys.exit(1)\n best_confs = {}\n best_technique = None\n for conf in self._exp_confs:\n technique = conf.technique\n if technique not in best_confs or conf.mapes[\"validation\"] < best_confs[technique].mapes[\"validation\"]:\n best_confs[technique] = conf\n for technique in best_confs:\n if not best_technique or best_confs[technique].mapes[\"validation\"] < best_confs[best_technique].mapes[\"validation\"]:\n best_technique = technique\n if bool(self._campaign_configuration['General']['details']):\n for run in run_tec_conf_set:\n for tec in run_tec_conf_set[run]:\n for conf in run_tec_conf_set[run][tec]:\n assert \"hp_selection\" in run_tec_conf_set[run][tec][conf]\n assert \"validation\" in run_tec_conf_set[run][tec][conf], \"training MAPE not found for \" + str(run) + str(tec) + str(conf)\n self._logger.info(\"Run %s - Technique %s - Conf %s - Training MAPE %f - Test MAPE %f\", str(run), ec.enum_to_configuration_label[tec], str(conf), run_tec_conf_set[run][tec][conf][\"hp_selection\"], run_tec_conf_set[run][tec][conf][\"validation\"])\n return best_confs, best_technique","def postprocess2(scores, classes, bboxes, iou_threshold=0.2, score_threshold=0.5):\n n = len(scores)\n \n count_per_class = {cls:0 for cls in classes}\n bbox_per_class = {cls:[] for cls in classes}\n score_per_class = {cls:[] for cls in classes}\n\n for i in range(n):\n count_per_class[classes[i]] += 1\n bbox_per_class[classes[i]] += [bboxes[i]]\n score_per_class[classes[i]] += [scores[i]]\n \n det_num = 0\n det_classes = [] \n det_scores = []\n det_bboxes = []\n\n for cls in count_per_class:\n current_count = count_per_class[cls]\n current_scores = np.array(score_per_class[cls], np.float32)\n current_bboxes = np.array(bbox_per_class[cls], np.int32)\n\n idx = np.argsort(current_scores)[::-1]\n sorted_scores = current_scores[idx]\n sorted_bboxes = current_bboxes[idx]\n\n top_k_ids = []\n size = 0\n i = 0\n\n while i < current_count:\n if sorted_scores[i] < score_threshold:\n break\n top_k_ids.append(i)\n det_num += 1\n det_classes.append(cls)\n det_scores.append(sorted_scores[i])\n det_bboxes.append(sorted_bboxes[i])\n size += 1\n i += 1\n\n while i < current_count:\n tiled_bbox_i = np.tile(sorted_bboxes[i], (size, 1))\n ious, iofs, ioss = iou_bbox(tiled_bbox_i, sorted_bboxes[top_k_ids])\n max_iou = np.max(ious)\n # max_iof = np.max(iofs)\n # max_ios = np.max(ioss)\n # temp = np.max((max_iof, max_ios))\n if max_iou > iou_threshold:\n i += 1\n else:\n break\n\n return det_num, np.array(det_scores, np.float32), np.array(det_classes, np.int32), np.array(det_bboxes, np.int32)","def __calculate_agg_shap_scores(self):\n self.agg_stats_timer = SimbaTimer(start=True)\n for clf_state, clf_state_name in zip(range(2), [\"ABSENT\", \"PRESENT\"]):\n self.results = {}\n self.df_save_path = os.path.join(\n self.shap_logs_path,\n \"SHAP_summary_{}_{}_{}.csv\".format(\n self.classifier_name, clf_state_name, self.datetime\n ),\n )\n shap_clf_sliced = self.shap_df[\n self.shap_df[self.classifier_name] == clf_state\n ]\n for feature_category, feature_time_bin in itertools.product(\n self.unique_feature_category_names, self.unique_time_bin_names\n ):\n if feature_category not in self.results.keys():\n self.results[feature_category] = {}\n feature_names_sliced = list(\n self.feature_categories_df.loc[\n :, (feature_category, feature_time_bin)\n ]\n )\n feature_names_sliced = [\n x\n for x in feature_names_sliced\n if str(x) != \"nan\" and x in shap_clf_sliced\n ]\n self.results[feature_category][feature_time_bin] = round(\n shap_clf_sliced[feature_names_sliced].sum(axis=1).mean() * 100, 6\n )\n self.__save_aggregate_scores()\n self.agg_stats_timer.stop_timer()\n self.visualization_timer = SimbaTimer(start=True)\n\n stdout_success(\n msg=f\"Aggregate SHAP statistics saved in {self.shap_logs_path} directory\",\n elapsed_time=self.agg_stats_timer.elapsed_time_str,\n )","def classify(self, testData):\n guesses = []\n self.posteriors = [] # Log posteriors are stored for later data analysis (autograder).\n for datum in testData:\n posterior = self.calculateLogJointProbabilities(datum)\n guesses.append(posterior.argMax())\n self.posteriors.append(posterior)\n return guesses","def train(self):\n\n # Step 1 - Obtain optimized weights for final model ------------------------------------------------------------\n\n t0 = time()\n\n # Check the training data for potential hazardous problems\n self.check_training_samples()\n\n opt_results = pd.DataFrame()\n kf_opt = StratifiedKFold(n_splits=self.kfold_cv, shuffle=True)\n rep_str, opt_str = '', ''\n\n if self.verbose:\n print('\\n\\n__ TRAINING STEP 1/2 \\_______________________________')\n print(' \\ Train with reverse %d-fold CV - %d time(s) /\\n' % (self.kfold_cv, self.n_repeat))\n\n for i_rep in range(self.n_repeat):\n\n if self.verbose:\n rep_str = '\\n_/--- Rep %d/%d' % (i_rep + 1, self.n_repeat)\n\n # Sample clf-net parameters to test\n param = [\n np.random.normal(loc=self.n_estimators,\n scale=self.n_estimators*self.param_tune_scale,\n size=self.kfold_cv),\n np.random.normal(loc=self.min_impurity_decrease,\n scale=self.min_impurity_decrease*self.param_tune_scale,\n size=self.kfold_cv),\n np.random.normal(loc=self.min_sample_leaf,\n scale=np.ceil(self.min_sample_leaf*self.param_tune_scale),\n size=self.kfold_cv),\n ]\n scores = list()\n\n for j_fold, (opt_idxs, cv_train_idxs) in enumerate(kf_opt.split(\n X=self.datas[self.train_idx].nidx_train,\n y=self.datas[self.train_idx].gen_labels(condense_labels=True))):\n\n if self.verbose:\n print(rep_str + ' - CV %d/%d ---\\_____\\n' % (j_fold + 1, self.kfold_cv))\n\n # set clf-net parameters\n self.n_estimators = param[0][j_fold]\n self.min_impurity_decrease = param[1][j_fold]\n self.min_sample_leaf = param[2][j_fold]\n self.clf_net = self.gen_rfc()\n\n # Split data\n opt_nidxs = np.array([self.datas[self.train_idx].nidx_train[i] for i in opt_idxs])\n cv_train_nidxs = np.array([self.datas[self.train_idx].nidx_train[i] for i in cv_train_idxs])\n\n # Partition train/eval nidx for reverse k-fold CV training\n _, _, opt_eval_nidxs, opt_train_nidxs = train_test_split(\n np.zeros(len(opt_nidxs)),\n opt_nidxs,\n test_size=1/(self.kfold_cv - 1),\n shuffle=True,\n stratify=self.datas[self.train_idx].gen_labels(nidxs=opt_nidxs, condense_labels=True))\n\n # Train clfs\n if self.verbose:\n print('\\n> Training base classifiers ...')\n self._train_clfs(train_nidxs=cv_train_nidxs)\n\n # Evaluate train with cv_train data\n if self.verbose:\n print('\\n> Evaluating base classifiers with cv_train partition ...')\n self.clfs_predict(nidxs_target=cv_train_nidxs, data=self.datas[self.train_idx], to_eval=True,\n eval_idx=self.train_idx)\n\n # Evaluate pre-optimization with opt_train data\n if self.verbose:\n print('\\n> Evaluating base classifiers with cv_eval partition ...')\n cv_res = self.clfs_predict(nidxs_target=opt_train_nidxs, data=self.datas[self.train_idx], to_eval=True,\n nidxs_train=cv_train_nidxs, eval_idx=self.train_idx)\n\n # Train clf-opt with opt_train partition results\n if self.verbose:\n print('\\n> Training clf-opt ...')\n self._train_clf_opt(predictions=cv_res)\n\n # Evaluate clf-opt with opt_eval partition\n if self.verbose:\n print('\\n> Evaluating optimized classifier with opt_test partition ...')\n opt_res = self.clfs_predict(nidxs_target=opt_eval_nidxs, data=self.datas[self.train_idx], to_eval=True,\n nidxs_train=cv_train_nidxs, eval_idx=self.train_idx)\n opt_results = opt_results.append(opt_res, ignore_index=True)\n\n # Append score to optimize clf-net parameter\n r = self.scores(opt_res['ytruth'], opt_res['ynet'])\n if not self.aim:\n scores.append(r['aucroc'])\n else:\n aim = self.aim.replace('hard', '')\n scores.append(r[aim])\n\n # reset link2featidx\n self.datas[self.train_idx].link2featidx = {}\n\n # Aggregate results from clf-net parameter search\n self._set_clf_net_param(param, scores)\n\n # STEP 2 - Train final model -----------------------------------------------------------------------------------\n # .clf_opt is already trained through previous iterations by using warm_start\n\n if self.verbose:\n print('\\n__ TRAINING STEP 2/2 \\_______________________________')\n print(' \\ Train final model with all train data /\\n')\n\n # Train clfs with all the data\n self._train_clfs()\n\n # Evaluate final clf-opt with all data\n print('\\n> Evaluating final classifier ...')\n self.clfs_predict(nidxs_target=self.datas[self.train_idx].nidx_train, to_eval=True, eval_idx=self.train_idx)\n print('** Because this is evaluating with the training data, classifier performances should be very high.')\n\n # Assign model ID - this is here so that if retrained, it would be known that it is not the same model anymore\n self.id = 'm_%s' % gen_id()\n\n if self.verbose:\n te = (time() - t0) / 60\n print('\\n Training took %.1f minutes on %d processors' % (te, os.cpu_count()))\n print('\\n__ __________')\n print(' \\ Training complete! /\\n')\n\n return opt_results","def get_optimal_postprocess(loaders=None, runner=None, logdir: str = \"\"):\n loaders[\"infer\"] = loaders[\"valid\"]\n\n runner.infer(\n model=runner.model,\n loaders=loaders,\n callbacks=[\n CheckpointCallback(resume=f\"{logdir}/checkpoints/best.pth\"),\n InferCallback(),\n ],\n )\n valid_masks = []\n probabilities = np.zeros((2220, 350, 525))\n for i, (batch, output) in enumerate(\n zip(loaders[\"infer\"].dataset, runner.callbacks[0].predictions[\"logits\"])\n ):\n image, mask = batch\n for m in mask:\n if m.shape != (350, 525):\n m = cv2.resize(m, dsize=(525, 350), interpolation=cv2.INTER_LINEAR)\n valid_masks.append(m)\n\n for j, probability in enumerate(output):\n if probability.shape != (350, 525):\n probability = cv2.resize(\n probability, dsize=(525, 350), interpolation=cv2.INTER_LINEAR\n )\n probabilities[i * 4 + j, :, :] = probability\n\n class_params = {}\n for class_id in range(4):\n print(class_id)\n attempts = []\n for t in range(0, 100, 10):\n t /= 100\n for ms in [\n 0,\n 100,\n 1000,\n 5000,\n 10000,\n 11000,\n 14000,\n 15000,\n 16000,\n 18000,\n 19000,\n 20000,\n 21000,\n 23000,\n 25000,\n 27000,\n 30000,\n 50000,\n ]:\n masks = []\n for i in range(class_id, len(probabilities), 4):\n probability = probabilities[i]\n predict, num_predict = post_process(sigmoid(probability), t, ms)\n masks.append(predict)\n\n d = []\n for i, j in zip(masks, valid_masks[class_id::4]):\n if (i.sum() == 0) & (j.sum() == 0):\n d.append(1)\n else:\n d.append(dice(i, j))\n\n attempts.append((t, ms, np.mean(d)))\n\n attempts_df = pd.DataFrame(attempts, columns=[\"threshold\", \"size\", \"dice\"])\n\n attempts_df = attempts_df.sort_values(\"dice\", ascending=False)\n print(attempts_df.head())\n best_threshold = attempts_df[\"threshold\"].values[0]\n best_size = attempts_df[\"size\"].values[0]\n\n class_params[class_id] = (best_threshold, int(best_size))\n\n print(class_params)\n return class_params","def getAllContributingAlgorithmsToBest(algnamelist, target_lb=1e-8, \n target_ub=1e2):\n \n print \"Generating best algorithm data from given algorithm list...\\n\", \n customgenerate(algnamelist)\n \n bestalgfilepath = 'bestCustomAlg'\n picklefilename = os.path.join(bestalgfilepath, 'bestalg.pickle')\n fid = open(picklefilename, 'r')\n bestalgentries = pickle.load(fid)\n fid.close()\n print 'loading of best algorithm data done.'\n \n countsperalgorithm = {}\n for (d, f) in bestalgentries:\n print 'dimension:', d, ', function:', f\n print f\n setofalgs = set(bestalgentries[d,f].algs)\n # pre-processing data to only look at targets >= target_lb:\n correctedbestalgentries = []\n for i in range(0,len(bestalgentries[d,f].target)):\n if ((bestalgentries[d,f].target[i] >= target_lb) and\n (bestalgentries[d,f].target[i] <= target_ub)):\n \n correctedbestalgentries.append(bestalgentries[d,f].algs[i])\n print len(correctedbestalgentries)\n # now count how often algorithm a is best for the extracted targets\n for a in setofalgs:\n # use setdefault to initialize with zero if a entry not existant:\n countsperalgorithm.setdefault((d, a), 0) \n countsperalgorithm[(d,a)] += correctedbestalgentries.count(a)\n \n selectedalgsperdimension = {}\n for (d,a) in sorted(countsperalgorithm):\n if not selectedalgsperdimension.has_key(d):\n selectedalgsperdimension[d] = []\n selectedalgsperdimension[d].append((countsperalgorithm[(d,a)], a))\n \n for d in sorted(selectedalgsperdimension):\n print d, 'D:'\n for (count, alg) in sorted(selectedalgsperdimension[d], reverse=True):\n print count, alg\n print '\\n'\n \n \n print \" done.\"","def train_all_categories(features, outputs, model, params_grid=None):\n results = dict() \n for output_class in outputs.keys():\n output_class=\"ASSAULT\"\n output = outputs[output_class]\n\n \tdefault_model = model()\n default_score = cross_validate(features, output, default_model)\n\n\tprint(\"Fine Tuning for class %s\"%(output_class))\n\t\n\tfine_tune_model = fine_tune(features, output, model(), verbose=1, params_grid=params_grid,)\n best_model, fine_tune_score = fine_tune_model.best_estimator_, fine_tune_model.best_score_\n results[output_class] = [(default_model, default_score), (best_model, fine_tune_score)]\n\tbreak\n return results","def Bayes_prediction(X, y, fold_number=10):\n D = X.shape[1]\n fold = KFold(n_splits=fold_number)\n cross_tab_all = []\n lamb_hat_all = []\n \n for train_index, test_index in fold.split(X, y):\n X_train, X_test = X.iloc[train_index], X.iloc[test_index]\n y_train, y_test = y.iloc[train_index], y.iloc[test_index]\n length = X_train.shape[0]\n pi_hat = y_train.mean()\n lamb_hat = np.zeros((2, D))\n \n for flag in range(2):\n for d in range(D):\n lamb_hat[flag][d] = (sum(X_train.iloc[i][d] * (y_train.iloc[i]==flag) for i in range(length))) / (sum(y_train.iloc[i]==flag for i in range(length)))\n\n y_pred = np.zeros(len(X_test))\n for i in range(len(X_test)):\n y_pred[i] = Bayes_classifier(pi_hat, X_test.iloc[i], lamb_hat)\n \n cross_tab = np.zeros((2, 2))\n for m in [0, 1]:\n for n in [0, 1]:\n cross_tab[m][n] = sum([(y_test.values[i]==m) & (y_pred[i]==n) for i in range(len(y_pred))]) \n \n cross_tab_all.append(cross_tab)\n lamb_hat_all.append(lamb_hat)\n \n cross_tab_all = sum(cross_tab_all)\n lamb_hat_all\n\n return lamb_hat_all, cross_tab_all","def compute_accuracy(data, num_labels = 4): \n \n # Declarating list to store results\n accuracies = []\n \n for instance in data:\n \n # Declarating list to store individual results\n instance_accuracies = []\n \n for i in np.arange(num_labels):\n \n # Computing and storing accuracy for each class\n instance_accuracies.append(accuracy_score(instance[:, 2 + i], instance[:, 2 + i + 4]))\n \n # Storing mean results of the instance\n accuracies.append(np.mean(instance_accuracies))\n \n # Returning mean of all results\n return np.mean(accuracies)","def random_objective(params, iteration, n_folds = N_FOLDS):\n\n start = timer()\n \n # Perform n_folds cross validation\n cv_results = lgb.cv(params, train_set, num_boost_round = 10000, nfold = n_folds, \n early_stopping_rounds = 100, metrics = 'l2', seed = 50, stratified=False)\n end = timer()\n best_score = np.max(cv_results['l2-mean'])\n \n # Loss must be minimized\n loss = 1 - best_score\n \n # Boosting rounds that returned the highest cv score\n n_estimators = int(np.argmax(cv_results['l2-mean']) + 1)\n \n # Return list of results\n return [loss, params, iteration, n_estimators, end - start]","def test_205_boosted_goal_difference_for_home_models_with_thresholds(self):\n\n def create_model_fn(fn_team: str):\n team_stat = Stats.n_sample_stats_for_team(cursor=db_in_cursor,\n team=fn_team,\n last_sample_date=self.model_date,\n n_samples=self.num_samples,\n normalize_by_matches=True)\n\n\n return FeatureModel(\n input_data=[self.home_boost + team_stat.goal_diff, team_stat.goal_diff],\n id=team_stat.team_name\n )\n\n\n for match_date in played_home_OR_away_before_dates:\n ####\n # Build model up to the day before the match\n ####\n self.home_boost = 0.72\n self.model_date = match_date - timedelta(days=1)\n self.num_samples = num_matches_in_season\n\n models: {str: FeatureModel} = FeatureModel.create_models_for_all_teams(\n model_making_fn=create_model_fn, entities=teams)\n\n self.persist_models(model_gen_date=self.model_date, model_description=self.shortDescription(), models=models)\n\n self.make_and_store_predictions_for_date(match_date=match_date, models=models, draw_range=(-0.792, 1.945))","def train_and_evaluate_k_fold(data_X, data_y, params, algo_factory, folds=5):\n kf = KFold(n_splits=folds)\n\n accuracies = []\n for train_index, test_index in kf.split(data_X):\n learning_algo = algo_factory(params)\n train_data_X, train_data_y = data_X[train_index], data_y[train_index]\n test_data_X, test_data_y = data_X[test_index], data_y[test_index]\n # Train\n learning_algo.fit(train_data_X, train_data_y)\n # Evaluate\n accuracy = learning_algo.score(test_data_X, test_data_y)\n # Save\n accuracies.append(accuracy)\n # return average accuracy\n return np.mean(accuracies)","def get_balancing_weight_factors(instances):\n sum_continue = sum(w for _, classification, w in instances\n if classification == Action.CONTINUE)\n sum_turn_peak = sum(w for _, classification, w in instances\n if classification == Action.TURN_PEAK)\n sum_backtrack = sum(w for _, classification, w in instances\n if classification == Action.BACKTRACK)\n\n min_sum = min(sum_continue, sum_turn_peak, sum_backtrack)\n factors = { Action.CONTINUE : multiplier_continue *\n float(min_sum) / sum_continue,\n Action.TURN_PEAK : multiplier_turn_peak *\n float(min_sum) / sum_turn_peak,\n Action.BACKTRACK : multiplier_backtrack *\n float(min_sum) / sum_backtrack }\n return factors","def get_metrics(cfg, model, X_anchor, y_anchor, X_gal, y_gal, annoy_index, vec_dim):\n rank10_acc = 0\n rank5_acc = 0\n rank1_acc = 0\n avg_acc = 0\n vote_res = 0\n\n l2 = []\n for anchor in range(0, len(X_anchor)):\n res = get_result(get_image_features(cfg, model, X_anchor[anchor]), annoy_index)\n vote = defaultdict(int)\n # Accuracy\n correct = 0\n for i in res[:10]:\n vote[y_gal[i]] += 1\n\n max_key = max(vote, key=vote.get)\n if max_key == y_anchor[anchor]:\n vote_res += 1\n \n\n for recomm in res[:10]:\n if y_gal[recomm] == y_anchor[anchor]:\n correct += 1 \n\n avg_acc += correct/len(res)\n\n # Mean Average Precision\n l1 = []\n for recomm in res[:10]:\n if y_gal[recomm] == y_anchor[anchor]:\n correct += 1\n l1.append(1)\n else:\n l1.append(0)\n l2.append(l1) \n\n # Rank10 Accuracy\n for each_val in res[:10]:\n if y_gal[each_val] == y_anchor[anchor]:\n rank10_acc += 1\n break\n \n # Rank5 Accuracy\n for each_val in res[:5]:\n if y_gal[each_val] == y_anchor[anchor]:\n rank5_acc += 1\n break\n\n # Rank1 Accuracy\n for each_val in res[:1]:\n if y_gal[each_val] == y_anchor[anchor]:\n rank1_acc += 1\n break\n\n print(\"Avg acc is :: {avg_acc}\".format(avg_acc = avg_acc/len(X_anchor)))\n print(\"Rank 10 acc is :: {rank10_acc}\".format(rank10_acc = rank10_acc/len(X_anchor)))\n print(\"Rank 5 acc is :: {rank5_acc}\".format(rank5_acc = rank5_acc/len(X_anchor)))\n print(\"Rank 1 acc is :: {rank1_acc}\".format(rank1_acc = rank1_acc/len(X_anchor)))\n print(\"Mean Avg Precision is :: {mAP}\".format(mAP=mean_average_precision(l2)))\n print(\"Vote res :: \", vote_res/len(X_anchor))\n\n return rank1_acc/len(X_anchor), mean_average_precision(l2)","def strategy(hand, num_die_sides):\n\n possible_holds = gen_all_holds(hand)\n best_val = 0\n best_score = 0\n dice_to_hold = []\n\n for hold in possible_holds:\n hold_val = expected_value(hold, NUM_DIE_SIDES, NUM_DICE - len(hold))\n\n hand_score = score(hold) + score(hand)\n if hand_score > best_val:\n # best_val = hold_val\n best_score = hand_score\n dice_to_hold = hold\n hand_copy = list(hand)\n sugg_hand = hand_copy.append(dice_to_hold)\n return (hand_score, sugg_hand)","def get_num_boosting_rounds(self):\n return self.n_estimators","def balence_classes(df, btol):\r\n #Find the least supported class and muliply by the tolerance coefficient to get max_count:\r\n ccounts = df['classification'].value_counts()\r\n max_count = np.min(ccounts.values) * btol\r\n #Create a new dataframe with balenced support:\r\n newdf = pd.DataFrame(columns=df.columns.values)\r\n for x in df.groupby('classification'):\r\n if x[1].shape[0] > max_count:\r\n newdf = newdf.append(x[1].sample(max_count).reset_index(drop=True))\r\n else:\r\n newdf = newdf.append(x[1].reset_index(drop=True))\r\n return newdf.reset_index(drop=True)","def findBestScore():\n resultList = []\n BestScore = 0\n # iterate through different max_depths from 1 to 19\n for max_depth in range(1,20):\n dtree = tree.DecisionTreeClassifier(max_depth=max_depth)\n trainng_score = []\n testing_score = []\n # run 10 different cross-validation\n for index in range(10):\n # split into cross-validation sets.\n cv_data_train, cv_data_test, cv_target_train, cv_target_test = \\\n cross_validation.train_test_split(X_train, y_train, test_size=0.1)\n # fit the model using the cross-validation data\n # and tune parameter, such as max_depth here\n dtree = dtree.fit(cv_data_train, cv_target_train)\n dtree.feature_importances_\n trainng_score += [dtree.score(cv_data_train,cv_target_train)]\n testing_score += [dtree.score(cv_data_test,cv_target_test)]\n\n # Compute the average score for both traning and testing data\n trainng_avgScore = 1.0 * sum(trainng_score)/len(trainng_score)\n testing_avgScore = 1.0 * sum(testing_score)/len(testing_score)\n\n # find the best score\n if testing_avgScore > BestScore:\n BestScore = testing_avgScore\n best_depth = max_depth\n resultList += [[best_depth, trainng_avgScore, testing_avgScore]]\n print ('The best average score and the corresponding max_depth is: ')\n return BestScore, best_depth","def train_and_score_bagging(network):\n\n train_predictions = pd.read_pickle('data/train_predictions.pkl.gz', compression='gzip')\n test_predictions = pd.read_pickle('data/test_predictions.pkl.gz', compression='gzip')\n\n train_actuals = pd.read_pickle('data/train_actuals.pkl.gz', compression='gzip')\n test_actuals = pd.read_pickle('data/test_actuals.pkl.gz', compression='gzip')\n\n\n train_x = np.array(train_predictions.values)\n train_y = train_actuals[0].values\n train_log_y = safe_log(train_y)\n test_x = np.array(test_predictions.values)\n test_y = test_actuals[0].values\n test_log_y = safe_log(test_y)\n\n model = compile_model(network)\n\n print('\\rNetwork')\n\n for property in network:\n print(property, ':', network[property])\n logging.info('%s: %s' % (property, network[property]))\n\n test = xgb.DMatrix(test_x)\n train = xgb.DMatrix(train_x, label=train_log_y)\n\n\n\n eval_set = [(test_x, test_log_y)]\n model.fit(train_x, train_log_y, early_stopping_rounds=20, eval_metric='mae', eval_set=eval_set,\n verbose=False)\n\n # eval_set = [(test, test_log_y)]\n # xgb.train(network, train, num_boost_round=5000, evals=eval_set, early_stopping_rounds=5)\n\n predictions = model.predict(test_x)\n # predictions = xgb.predict(test_x)\n inverse_predictions = safe_exp(predictions)\n score = mean_absolute_error(test_y, inverse_predictions)\n mape = safe_mape(test_y, inverse_predictions)\n\n print('\\rResults')\n\n best_round = xgb.best_iteration\n\n if np.isnan(score):\n score = 9999\n\n print('best round:', best_round)\n print('loss:', score)\n print('mape:', mape)\n print('-' * 20)\n\n logging.info('best round: %d' % best_round)\n logging.info('loss: %.4f' % score)\n logging.info('mape: %.4f' % mape)\n logging.info('-' * 20)\n\n eval_results({'xgb_predictions': {\n 'actual_y': test_y,\n 'y_predict': inverse_predictions\n }\n })\n\n range_results({\n 'xgb_predictions': inverse_predictions,\n }, test_y)","def _mean_match_multiclass_accurate(\n mean_match_candidates,\n bachelor_preds,\n candidate_preds,\n candidate_values,\n random_state,\n hashed_seeds,\n):\n if mean_match_candidates == 0:\n imp_values = np.argmax(bachelor_preds, axis=1)\n\n else:\n _to_2d(bachelor_preds)\n _to_2d(candidate_preds)\n\n num_bachelors = bachelor_preds.shape[0]\n kd_tree = KDTree(candidate_preds, leafsize=16, balanced_tree=False)\n _, knn_indices = kd_tree.query(\n bachelor_preds, k=mean_match_candidates, workers=-1\n )\n\n # We can skip the random selection process if mean_match_candidates == 1\n if mean_match_candidates == 1:\n index_choice = knn_indices\n\n else:\n # Come up with random numbers 0-mean_match_candidates, with priority given to hashed_seeds\n if hashed_seeds is None:\n ind = random_state.randint(mean_match_candidates, size=(num_bachelors))\n else:\n ind = hashed_seeds % mean_match_candidates\n\n index_choice = knn_indices[np.arange(knn_indices.shape[0]), ind]\n\n imp_values = np.array(candidate_values)[index_choice]\n\n return imp_values","def test_gbc(x, y, tune):\n # Perform classification without tuning. It was determined through trial-and-error\n # that log2 features produced the highest accuracy\n gbt = GradientBoostingClassifier(max_features=\"log2\")\n pipeline = create_pipeline(gbt)\n return accuracy(pipeline, x, y)","def classify( self, data):\n\n\t\t\"*** YOUR CODE HERE ***\"\n\t\tguesses = np.zeros(len(data))\n\n\t\tfor k in range(len(self.classifiers)):\n\t\t\tclassifier = self.classifiers[k]\n\t\t\tguesses += np.dot(classifier.classify(data),self.alphas[k])\n\t\t\n\t\tguesses = np.sign(guesses)\n\t\tguesses[np.where(guesses == 0)[0]] = np.repeat(np.expand_dims(np.random.choice([-1,1]),axis=0),len(np.where(guesses == 0)[0]),axis=0)\n\t\treturn guesses\n\t\t# util.raiseNotDefined()","def optimal_instances_per_class(df, factor=1.0, draw=False):\n # `bincount` returns the number of instances we have for each website\n counts = np.bincount(df.class_label.tolist())\n hist, bin_edges = np.histogram(counts)\n if draw:\n inst_counts = get_num_instances(df)\n inst_counts.hist(cumulative=-1, bins=100)\n plt.xlabel('Num of instances')\n plt.ylabel('Num of classes with x or more insts')\n plt.show()\n\n # scale the y-axis\n dx = bin_edges[1] - bin_edges[0]\n cum_hist = np.cumsum(hist) * dx\n\n # get the inverse cumulative sum\n inv_cum_hist = max(cum_hist) - cum_hist\n\n # compute the harmonic mean of tuples (y=f(x), x)\n hms = [harmonic_mean(x, y, factor) if y > 0 and x > 0 else 0\n for x, y in zip(bin_edges[1:], inv_cum_hist)]\n\n print(hms)\n\n # find index for max harmonic mean\n i = np.argmax(hms)\n\n # this is the optimal number of instances:\n opt_num_insts = int(bin_edges[i])\n\n # which leaves us with this number of classes:\n opt_num_classes = len(counts[counts >= opt_num_insts])\n\n if draw:\n print(\"Optimal number of instances:\", opt_num_insts)\n print(\"Optimal number of classes:\", opt_num_classes)\n\n return opt_num_insts, opt_num_classes","def bin_class_grid_search(model_class, data_loader, hp_file,\n loader_args=None, model_args=None,\n folds=4, random_oversample=False):\n loader = data_loader(**loader_args)\n\n # load index values from main table\n data_ix = loader.get_index()\n\n # load hyperparameters from file\n with open(hp_file, 'r') as f:\n hyperparameters = ast.literal_eval(f.read())\n\n # create a list of dicts with hyperparameters for each experiment to run\n keys, values = zip(*hyperparameters.items())\n experiments = [dict(zip(keys, v)) for v in itertools.product(*values)]\n exp_df = pd.DataFrame(experiments)\n\n # prepare for storing confusion matrix and accuracy results to file\n cm = np.zeros((len(experiments), 2, 2), dtype=int)\n cm_df_cols = ['CM True Neg', 'CM False Pos', 'CM False Neg', 'CM True Pos']\n results_path = 'data/results/gridsearch_results_{:%Y%m%d_%H%M%S}.csv'.format(datetime.now())\n\n # fit model using k-fold verification\n kf = KFold(n_splits=folds, shuffle=True)\n\n for j, fold_indexes in enumerate(kf.split(data_ix)):\n # load train and validation data\n data_train, target_train, data_val, target_val = loader.load_train_val(fold_indexes[0], fold_indexes[1])\n\n # determine shape of input arrays\n input_shape = loader.get_input_shape()\n\n # oversample to correct for class imbalance\n if random_oversample:\n ros = RandomOverSampler()\n os_index, target_train = ros.fit_sample(np.arange(len(fold_indexes[0])).reshape(-1, 1), target_train)\n if isinstance(data_train, list):\n data_train = [data_train_part[os_index.squeeze()] for data_train_part in data_train]\n else:\n data_train = data_train[os_index.squeeze()]\n\n logging.debug('Fold {} of {}'.format(j + 1, folds))\n\n for i, experiment in enumerate(experiments):\n logging.debug(experiment)\n model = model_class(input_shape, **model_args, **experiment)\n # TODO: track oos accuracy per epoch\n history = model.fit(data_train, target_train, validation_data=(data_val, target_val))\n predict_val = model.predict(data_val)\n\n cm[i, :, :] = cm[i, :, :] + confusion_matrix(target_val, predict_val.round())\n cm_df = pd.DataFrame(cm.reshape((cm.shape[0], 4)), columns=cm_df_cols)\n results_df = exp_df.join(cm_df)\n # TODO: also store run time\n results_df.to_csv(results_path)","def train_epoch(self):\n # We can't validate a winner for submissions generated by the learner,\n # so we will use a winner-less match when getting rewards for such states\n blank_match = {\"winner\":None}\n\n learner_submitted_actions = 0\n null_actions = 0\n\n # Shuffle match presentation order\n if(self.N_TEMP_TRAIN_MATCHES):\n path_to_db = \"../data/competitiveMatchData.db\"\n sources = {\"patches\":self.TEMP_TRAIN_PATCHES, \"tournaments\":[]}\n print(\"Adding {} matches to training pool from {}.\".format(self.N_TEMP_TRAIN_MATCHES, path_to_db))\n temp_matches = pool.match_pool(self.N_TEMP_TRAIN_MATCHES, path_to_db, randomize=True, match_sources=sources)[\"matches\"]\n else:\n temp_matches = []\n data = self.training_data + temp_matches\n\n shuffled_matches = random.sample(data, len(data))\n for match in shuffled_matches:\n for team in self.teams:\n # Process match into individual experiences\n experiences = mp.process_match(match, team)\n for pick_id, experience in enumerate(experiences):\n # Some experiences include NULL submissions (usually missing bans)\n # The learner isn't allowed to submit NULL picks so skip adding these\n # to the buffer.\n state,actual,_,_ = experience\n (cid,pos) = actual\n if cid is None:\n null_actions += 1\n continue\n # Store original experience\n self.replay.store([experience])\n self.step_count += 1\n\n # Give model feedback on current estimations\n if(self.step_count > self.observations):\n # Let the network predict the next action\n feed_dict = {self.ddq_net.online_ops[\"input\"]:[state.format_state()],\n self.ddq_net.online_ops[\"valid_actions\"]:[state.get_valid_actions()]}\n q_vals = self.ddq_net.sess.run(self.ddq_net.online_ops[\"valid_outQ\"], feed_dict=feed_dict)\n sorted_actions = q_vals[0,:].argsort()[::-1]\n top_actions = sorted_actions[0:4]\n\n if(random.random() < self.epsilon):\n pred_act = random.sample(list(top_actions), 1)\n else:\n # Use model's top prediction\n pred_act = [sorted_actions[0]]\n\n for action in pred_act:\n (cid,pos) = state.format_action(action)\n if((cid,pos)!=actual):\n pred_state = deepcopy(state)\n pred_state.update(cid,pos)\n r = get_reward(pred_state, blank_match, (cid,pos), actual)\n new_experience = (state, (cid,pos), r, pred_state)\n\n self.replay.store([new_experience])\n learner_submitted_actions += 1\n\n if(self.epsilon > 0.1):\n # Reduce epsilon over time\n self.epsilon -= self.eps_decay_rate\n\n # Use minibatch sample to update online network\n if(self.step_count > self.pre_training_steps):\n self.train_step()\n\n if(self.step_count % self.target_update_frequency == 0):\n # After the online network has been updated, update target network\n _ = self.ddq_net.sess.run(self.ddq_net.target_ops[\"target_update\"])\n\n # Get training loss, training_acc, and val_acc to return\n loss, train_acc = self.validate_model(self.training_data)\n _, val_acc = self.validate_model(self.validation_data)\n return (loss, train_acc, val_acc)","def algo_CVmetrics(classifier_object, X_train, Y_train):\r\n \r\n cv = RepeatedStratifiedKFold(n_splits = 5, n_repeats = 3, random_state = seed_custom)\r\n \r\n metricslist = {'f2': make_scorer(metrics.fbeta_score, beta = 2), \r\n 'balacc': make_scorer(metrics.balanced_accuracy_score),\r\n 'precision': make_scorer(metrics.precision_score),\r\n 'recall': make_scorer(metrics.recall_score)}\r\n \r\n cv_results = cross_validate(classifier_object, X_train, Y_train, cv = cv, scoring = metricslist, return_estimator = True)\r\n \r\n f2_mean = np.mean(cv_results['test_f2'])\r\n f2_std = np.std(cv_results['test_f2'])\r\n \r\n balacc_mean = np.mean(cv_results['test_balacc'])\r\n balacc_std = np.std(cv_results['test_balacc'])\r\n\r\n precision_mean = np.mean(cv_results['test_precision'])\r\n precision_std = np.std(cv_results['test_precision'])\r\n \r\n recall_mean = np.mean(cv_results['test_recall'])\r\n recall_std = np.std(cv_results['test_recall'])\r\n \r\n scorebox = pd.DataFrame(np.zeros((1,8)), columns = list(['F2-Score Mean', 'F2-Score STD', 'Balanced Accuracy Mean', 'Balanced Accuracy STD',\r\n 'Precision Mean', 'Precision STD', 'Recall Mean', 'Recall STD']))\r\n \r\n scorebox.iloc[0,0] = f2_mean\r\n scorebox.iloc[0,1] = f2_std\r\n scorebox.iloc[0,2] = balacc_mean\r\n scorebox.iloc[0,3] = balacc_std\r\n scorebox.iloc[0,4] = precision_mean\r\n scorebox.iloc[0,5] = precision_std\r\n scorebox.iloc[0,6] = recall_mean\r\n scorebox.iloc[0,7] = recall_std \r\n \r\n scorebox = np.round(scorebox, 3)\r\n \r\n print(\"Model has a mean CV balanced accuracy of {0}, (Std: {1})\".format(round(balacc_mean,3), round(balacc_std,3)))\r\n print(\"Model has a mean CV F2_Score of {0}, (Std: {1})\".format(round(f2_mean,3), round(f2_std,3)))\r\n print(\"Model has a mean CV Precision of {0}, (Std: {1})\".format(round(precision_mean,3), round(precision_std,3)))\r\n print(\"Model has a mean CV Recall of {0}, (Std: {1})\".format(round(recall_mean,3), round(recall_std,3)))\r\n \r\n return scorebox","def calculate_average_run_accuracy(self):\n overall_true_rate, true_positive_rate, true_negative_rate, false_positive_rate, false_negative_rate, true_positive_rate_cutoff, true_negative_rate_cutoff, \\\n false_positive_rate_cutoff, false_negative_rate_cutoff, unclassified_cutoff, matthews_correlation_coefficient, brier_score, auc_score, fit_time, hmeasure = [0] * 15\n balanced_accuracy_arr = []\n auc_arr = []\n hmeasure_arr = []\n brier_score_arr = []\n fit_time_arr = []\n mcc_arr = []\n true_positive_arr = []\n true_negative_arr = []\n false_positive_arr = []\n false_negative_arr = []\n\n count = 0\n for result_dictionary in self.errors:\n for z in range(len(result_dictionary[\"balanced_accuracy_arr\"])):\n overall_true_rate += result_dictionary[\"balanced_accuracy_arr\"][z]\n true_positive_rate += result_dictionary[\"true_positive_rate_arr\"][z]\n true_negative_rate += result_dictionary[\"true_negative_rate_arr\"][z]\n false_positive_rate += result_dictionary[\"false_positive_rate_arr\"][z]\n false_negative_rate += result_dictionary[\"false_negative_rate_arr\"][z]\n matthews_correlation_coefficient += result_dictionary[\"mcc_arr\"][z]\n auc_score += result_dictionary[\"auc_arr\"][z]\n brier_score += result_dictionary[\"brier_score_arr\"][z]\n fit_time += result_dictionary[\"fit_time_arr\"][z]\n hmeasure += result_dictionary[\"hmeasure_arr\"][z]\n count += 1\n\n true_positive_rate_cutoff += result_dictionary[\"avg_true_positive_rate_with_prob_cutoff\"]\n true_negative_rate_cutoff += result_dictionary[\"avg_true_negative_rate_with_prob_cutoff\"]\n false_positive_rate_cutoff += result_dictionary[\"avg_false_positive_rate_with_prob_cutoff\"]\n false_negative_rate_cutoff += result_dictionary[\"avg_false_negative_rate_with_prob_cutoff\"]\n unclassified_cutoff += result_dictionary[\"avg_false_negative_rate_with_prob_cutoff\"]\n balanced_accuracy_arr += result_dictionary[\"balanced_accuracy_arr\"]\n hmeasure_arr += result_dictionary[\"hmeasure_arr\"]\n auc_arr += result_dictionary[\"auc_arr\"]\n brier_score_arr += result_dictionary[\"brier_score_arr\"]\n fit_time_arr += result_dictionary[\"fit_time_arr\"]\n mcc_arr += result_dictionary[\"mcc_arr\"]\n true_positive_arr += result_dictionary[\"true_positive_rate_arr\"]\n true_negative_arr += result_dictionary[\"true_negative_rate_arr\"]\n false_positive_arr += result_dictionary[\"false_positive_rate_arr\"]\n false_negative_arr += result_dictionary[\"false_negative_rate_arr\"]\n\n avg_run_results = [None] * 31\n avg_run_results[0] = matthews_correlation_coefficient / float(count)\n avg_run_results[1] = brier_score / float(count)\n avg_run_results[2] = overall_true_rate / float(count)\n avg_run_results[3] = true_positive_rate / float(count)\n avg_run_results[4] = true_negative_rate / float(count)\n avg_run_results[5] = false_positive_rate / float(count)\n avg_run_results[6] = false_negative_rate / float(count)\n avg_run_results[7] = true_positive_rate_cutoff / float(len(self.errors))\n avg_run_results[8] = true_negative_rate_cutoff / float(len(self.errors))\n avg_run_results[9] = false_positive_rate_cutoff / float(len(self.errors))\n avg_run_results[10] = false_negative_rate_cutoff / float(len(self.errors))\n avg_run_results[11] = unclassified_cutoff / float(len(self.errors))\n avg_run_results[12] = fit_time / float(count)\n avg_run_results[14] = balanced_accuracy_arr\n avg_run_results[15] = auc_score / float(count)\n avg_run_results[16] = auc_arr\n avg_run_results[17] = brier_score_arr\n avg_run_results[18] = fit_time_arr\n avg_run_results[19] = mcc_arr\n avg_run_results[13] = self.calculate_std_deviation(balanced_accuracy_arr)\n avg_run_results[20] = self.calculate_std_deviation(mcc_arr)\n avg_run_results[21] = self.calculate_std_deviation(brier_score_arr)\n avg_run_results[22] = self.calculate_std_deviation(auc_arr)\n avg_run_results[23] = self.calculate_std_deviation(fit_time_arr)\n avg_run_results[24] = self.calculate_std_deviation(true_positive_arr)\n avg_run_results[25] = self.calculate_std_deviation(true_negative_arr)\n avg_run_results[26] = self.calculate_std_deviation(false_positive_arr)\n avg_run_results[27] = self.calculate_std_deviation(false_negative_arr)\n avg_run_results[28] = hmeasure / float(count)\n avg_run_results[29] = self.calculate_std_deviation(hmeasure_arr)\n avg_run_results[30] = hmeasure_arr\n\n return avg_run_results","def _mean_match_multiclass_fast(\n mean_match_candidates, bachelor_preds, random_state, hashed_seeds\n):\n if mean_match_candidates == 0:\n imp_values = np.argmax(bachelor_preds, axis=1)\n\n else:\n num_bachelors = bachelor_preds.shape[0]\n\n # Turn bachelor_preds into discrete cdf:\n bachelor_preds = bachelor_preds.cumsum(axis=1)\n\n # Randomly choose uniform numbers 0-1\n if hashed_seeds is None:\n # This is the fastest way to adjust for numeric\n # imprecision of float16 dtype. Actually ends up\n # barely taking any time at all.\n bp_dtype = bachelor_preds.dtype\n unif = np.minimum(\n random_state.uniform(0, 1, size=num_bachelors).astype(bp_dtype),\n bachelor_preds[:, -1],\n )\n else:\n unif = []\n for i in range(num_bachelors):\n np.random.seed(seed=hashed_seeds[i])\n unif.append(np.random.uniform(0, 1, size=1)[0])\n unif = np.array(unif)\n\n # Choose classes according to their cdf.\n # Distribution will match probabilities\n imp_values = np.array(\n [\n np.searchsorted(bachelor_preds[i, :], unif[i])\n for i in range(num_bachelors)\n ]\n )\n\n return imp_values","def evaluate(clf, dataset, feature_list, features, labels, num_iter, params):\n\n features_train, features_test, labels_train, labels_test = \\\n train_test_split(features, labels, test_size=0.3, random_state=42)\n\n\n\n precision_values = []\n recall_values = []\n accuracy_values = []\n print clf\n for i in xrange(0, num_iter):\n #print params\n clf = GridSearchCV(clf, params)\n clf.fit(features_train, labels_train)\n print '*****************************'\n print clf.best_estimator_\n print clf.best_params_\n\n clf = clf.best_estimator_\n #test_classifier(clf, dataset, feature_list)\n pred = clf.predict(features_test)\n precision_values.append(precision_score(labels_test, pred))\n recall_values.append(recall_score(labels_test, pred))\n accuracy_values.append(accuracy_score(labels_test, pred))\n print 'Recall score: ', mean(recall_values)\n print 'Precision score: ', mean(precision_values)\n print 'Accuracy score: ' , mean(accuracy_values)","def get_balancing_probabilities(instances):\n count_continue = sum(classification == Action.CONTINUE \n for _, classification in instances)\n count_turn_peak = sum(classification == Action.TURN_PEAK\n for _, classification in instances)\n count_backtrack = sum(classification == Action.BACKTRACK\n for _, classification in instances)\n\n min_count = min(count_continue, count_turn_peak, count_backtrack)\n probabilities = { Action.CONTINUE : multiplier_continue * \n float(min_count) / count_continue,\n Action.TURN_PEAK : multiplier_turn_peak * \n float(min_count) / count_turn_peak,\n Action.BACKTRACK : multiplier_backtrack *\n float(min_count) / count_backtrack }\n return probabilities","def best_threshold_from_folds(y_tuples, scoring=f1_score, step_size=0.01, maximize=True):\n thresholds, scores = [], []\n for _, y_true, y_pred in y_tuples:\n t, s = find_best_threshold(y_true, y_pred, step_size, scoring, maximize=maximize)\n thresholds.append(t)\n scores.append(s)\n\n mean_threshold = np.mean(thresholds)\n mean_score = np.mean([score_for_threshold(y, y_hat, scoring, mean_threshold) for _, y, y_hat in y_tuples])\n return mean_threshold, mean_score","def findRFBestN():\n resultList = []\n BestScore = 0\n nList = [ n for n in range(1,200) if n%10 == 0]\n for n in nList:\n rforest = ensemble.RandomForestClassifier(max_depth=5, n_estimators=n)\n trainng_score = []\n testing_score = []\n # run 10 different cross-validation\n for index in range(10):\n # split into cross-validation sets.\n cv_data_train, cv_data_test, cv_target_train, cv_target_test = \\\n cross_validation.train_test_split(X_train, y_train, test_size=0.1)\n\n # fit the model using the cross-validation data\n # and tune parameter, such as max_depth here\n rforest = rforest.fit(cv_data_train, cv_target_train)\n trainng_score += [rforest.score(cv_data_train,cv_target_train)]\n testing_score += [rforest.score(cv_data_test,cv_target_test)]\n\n # Compute the average score for both traning and testing data\n trainng_avgScore = 1.0 * sum(trainng_score)/len(trainng_score)\n testing_avgScore = 1.0 * sum(testing_score)/len(testing_score)\n\n # find the best score\n if testing_avgScore > BestScore:\n BestScore = testing_avgScore\n best_n = n\n resultList += [[n, trainng_avgScore, testing_avgScore]]\n print ('The best average score and the corresponding n_estimator is: ')\n return BestScore, best_n","def evaluation_detections(thresholds, bboxes_gt, bboxes_detected, num_instances):\r\n TP = np.zeros(len(thresholds), dtype=int)\r\n FP = np.zeros(len(thresholds), dtype=int)\r\n\r\n scores_detections = [[] for i in range(len(thresholds))]\r\n # scores_detections is pair of values [result, confidence] where result is true if the example is correctly\r\n # classified and confidence is the confidence of the prediction. It's used to compute the precision-recall\r\n # curve. Confidence score is random if the predicted scores do not belong to a detector.\r\n\r\n for key in bboxes_detected.keys():\r\n for bbox_noisy in bboxes_detected[key]:\r\n if key in bboxes_gt: # if we have detected stuff and it is in the gt\r\n scores = [bbox_iou(bbox_noisy[1:5], bbox[1:5]) for bbox in bboxes_gt[key]]\r\n max_score = max(scores)\r\n for i, threshold in enumerate(thresholds):\r\n if max_score > threshold:\r\n TP[i] += 1\r\n # we give correct boxes a slightly higher confidence score\r\n scores_detections[i].append([1, bbox_noisy[5]])\r\n else:\r\n FP[i] += 1\r\n scores_detections[i].append([0, bbox_noisy[5]])\r\n else: # if we have detected stuff and it is not in the gt\r\n for i, threshold in enumerate(thresholds):\r\n FP[i] += 1\r\n\r\n FN = num_instances - TP # number of instances not detected\r\n return TP, FP, FN, np.array(scores_detections)","def runUCB(self):\n \n #Init vars, N number of user sessions, d=number of ads\n N = self.myDS.shape[0] \n d = self.myDS.shape[1] \n total_reward=0\n self.opt_selected=[]\n \n #Declare vars to count to calculate upper bounds\n numbers_of_selections = [0] * d\n sums_of_rewards = [0] * d\n \n #Calcultate confidance bounds\n for n in range(0,N):\n ad=0\n max_upper_bound=0\n for i in range (0,d):\n if (numbers_of_selections[i]>0):\n average_reward=sums_of_rewards[i]/numbers_of_selections[i]\n delta_i=math.sqrt(3/2 * math.log(n+1) / numbers_of_selections[i])\n upper_bound=average_reward+delta_i\n else:\n upper_bound=1e400\n if upper_bound>max_upper_bound:\n max_upper_bound=upper_bound\n ad = i\n self.opt_selected.append(ad)\n numbers_of_selections[ad]=numbers_of_selections[ad]+1\n reward=self.myDS.values[n,ad]\n sums_of_rewards[ad]=sums_of_rewards[ad]+reward\n total_reward=total_reward+reward\n \n return total_reward","def BayesPaperStats(maxIters, numRuns):\n\n comm = MPI.COMM_WORLD\n rank = comm.Get_rank()\n\n assert comm.Get_size() == numRuns, \"Please ensure there is one process running per run i.e \" + str(numRuns) + \" processes.\"\n \n problemBounds = {\"Bfield\": choco.uniform(10, 1300), \"T\": choco.uniform(50, 230), \"Btheta\": choco.uniform(0, 90), \"Etheta\": choco.uniform(0, 90)}\n\n # The target for each algorithm. This was determined by using the values in the literature, so there is clearly some deviation either due to the detuning or computation.\n globalFoM = 1.033\n\n if rank == 0:\n timeList = []\n iterationList = []\n\n # Set up the database for the chocolate optimiser.\n connection = choco.SQLiteConnection(\"sqlite:///bayes_paper_\" + str(rank) + \"_db.db\")\n\n # Define which solver will be used.\n solver = choco.Bayes(connection, problemBounds, utility_function = \"ei\", n_bootstrap = int(np.ceil(maxIters/10)), clear_db = True)\n\n # Clear the database. TODO: To do this?\n connection.clear()\n\n # Start timing.\n startTime = time.time()\n timeElapsed = None\n iterationSuccess = None\n\n # Start optimisation.\n for iteration in range(maxIters):\n\n # Make one suggestion.\n try:\n token, nextParams = solver.next()\n except:\n print(\"Error suggesting a new point. Here are the last set of parameters sampled:\")\n print(str(nextParams))\n print(\"Iteration number: \" + str(iteration))\n continue\n\n # Check what FoM this gives. Go negative as this is a minimisation routine.\n fEval = abs(FitnessPaper(**nextParams))\n\n # Update best FoM.\n if fEval >= globalFoM:\n # The algorithm has managed to surpass or equal the paper value.\n iterationSuccess = iteration\n timeElapsed = time.time() - startTime\n \n if rank == 0:\n iterationList.append(iterationSuccess)\n timeList.append(timeElapsed)\n\n break\n \n # Tell the optimiser about the result.\n solver.update(token, fEval)\n\n # Run complete. Send results to main process. Tags are unique identifiers.\n if rank != 0:\n comm.send(timeElapsed, dest = 0, tag = 1)\n comm.send(iterationSuccess, dest = 0, tag = 2)\n\n # Wait for all the processes to end.\n comm.Barrier()\n\n if rank == 0:\n # Aggregate the data.\n for process in range(comm.Get_size() - 1):\n # Get the data.\n individualTime = None\n individualTime = comm.recv(individualTime, source = process + 1, tag = 1)\n\n individualIter = None\n individualIter = comm.recv(individualIter, source = process + 1, tag = 2)\n\n if individualIter is not None:\n # Both values must therefore be non-null.\n iterationList.append(individualIter)\n timeList.append(individualTime)\n\n avgRuntime = np.average(timeList)\n avgIters = np.average(iterationList)\n try:\n\n fastestTime = np.min(timeList)\n\n except ValueError:\n \n # List is empty.\n fastestTime = float('NaN')\n\n numSuccess = len(iterationList)\n successRate = numSuccess/numRuns\n\n print(\"Bayesian optimisation paper testing complete! Here are the stats:\")\n print(\"Number of successful runs: \" + str(numSuccess) + \" (Success rate of \" + str(successRate) + \")\")\n print(\"Average iterations required for success: \" + str(avgIters))\n print(\"Average time required for success: \" + str(avgRuntime))\n print(\"Fastest convergence time: \" + str(fastestTime))\n print(\"------------------------------------------------------------------------------------------------------------------\")\n \n return","def get_combinations(classes_folder='./data/CASIA1_classes_by_unbalanced_kmeans/', \n originals='./data/CASIA1_originals', fakes_ela='./data/CASIA1_fakes_ela'):\n classes_ = []\n for i in range(20):\n classes_.append('{}{}' .format(classes_folder, i+1))\n\n medians_ = [0,3,5,7,9,11,13,15,17,19]\n\n iterations_ = []\n for i in range(21):\n iterations_.append(i)\n\n threshold_ = []\n for i in range(40):\n threshold_.append(i)\n\n for i, item in enumerate(classes_):\n fakes_list = os.listdir(item)\n fakes = load_fakes(fakes_list, item, originals)\n\n best = 0\n best_median_filter_size = 0\n best_number_of_iterations = 0\n best_thresh = 0\n for x, median_filter_size in enumerate(medians_):\n for y, number_of_iterations in enumerate(iterations_):\n for t, thresh in enumerate(threshold_):\n whole_score = 0\n for e, elem in enumerate(fakes):\n image = cv2.imread(os.path.join(fakes_ela, elem.path.split('\\\\')[-1]))\n\n if thresh > 0:\n image_ = pywt.threshold(image, thresh, 'soft')\n image = cv2.normalize(image_, image, 0, 1, cv2.NORM_MINMAX)\n image = 255 * image\n image = image.astype(np.uint8)\n\n image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\n \n image = cv2.inRange(image, np.array([0,0,0]), np.array([180,255,60]))\n image = cv2.bitwise_not(image)\n\n if median_filter_size > 0:\n image = cv2.medianBlur(image, median_filter_size)\n\n kernel = np.ones((3, 3), np.uint8)\n image = cv2.morphologyEx(image, cv2.MORPH_GRADIENT, kernel, iterations=number_of_iterations)\n\n cnts = cv2.findContours(image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n cnts = imutils.grab_contours(cnts)\n\n max_idx = 0\n max_pnts = 0\n for u, ulem in enumerate(cnts):\n if cv2.contourArea(ulem) < max_pnts:\n continue\n else:\n max_idx = u\n max_pnts = cv2.contourArea(ulem)\n\n if len(cnts) > 0:\n (x, y, w, h) = cv2.boundingRect(cnts[max_idx])\n pred = {\n \"x\": x,\n \"y\": y,\n \"w\": w,\n \"h\": h\n }\n else:\n pred = None\n\n whole_score += evaluate_augmentation_fit(pred, elem)\n if best < whole_score:\n best = whole_score\n best_median_filter_size = median_filter_size\n best_number_of_iterations = number_of_iterations\n best_thresh = thresh\n print(\"Class: {}; MedianFilterSize: {}; Iterations: {}; Thresh: {}; Score: {}\" .format(item, median_filter_size, number_of_iterations, thresh, round(whole_score, 2)))\n print(\"###########\")\n print(\"Best: {} -> {} % ({}, {}, {})\" .format(round(best, 2), round((best/len(fakes)), 2), best_median_filter_size, best_number_of_iterations, best_thresh))\n print(\"###########\")","def learn_with_bootstrapping(self, sample_count=10000):\n tic = time.clock()\n training_set_size = 150 # TODO: change to 1000, 500 or something\n sample_pool = self.training_stream.extract_training_patches(sample_count, negative_ratio=1.)\n # initialize weights\n weighted_patches = []\n for patch in sample_pool: # weight all patches: training pool P\n weighted_patches.append([patch, 1. / len(sample_pool)])\n # if patch.label == +1:\n # pos_patch = patch # PRESENTATION, REPORT\n # shuffle training pool\n weighted_patches = random_sample_weighted_patches(weighted_patches, len(weighted_patches))\n\n if self.algorithm == 'adaboost': # Shuffle the training data\n training_data = random_sample_weighted_patches(weighted_patches, len(weighted_patches))\n elif self.algorithm == 'wald': # Sample training_set_size samples\n training_data = random_sample_weighted_patches(weighted_patches, training_set_size)\n\n for t in range(self.layers): # choose the weak classifier with the minimum error\n print \"Learn with bootstrapping using %s, layer #%d\" % (self.algorithm.title(), t+1)\n\n if self.algorithm == 'adaboost':\n h_t = self._fetch_best_weak_classifier(weighted_patches)\n elif self.algorithm == 'wald':\n h_t = self._fetch_best_weak_classifier(training_data)\n # h_t.visualize(pos_patch) # PRESENTATION, REPORT\n self.classifiers.append(copy.deepcopy(h_t)) # add it to the strong classifier\n\n if self.algorithm == 'adaboost':\n self.classifiers[-1].update_alpha(weighted_patches)\n weighted_patches = self._adaboost_reweight(weighted_patches, t)\n elif self.algorithm == 'wald':\n kde_n, kde_p, xs_n, xs_p = self._estimate_ratios(training_data, t)\n # find decision thresholds for the strong classifier\n self._tune_thresholds(kde_n, kde_p, xs_n, xs_p, t)\n # throw away training samples that fall in our thresholds\n weighted_patches = self._reweight_and_discard_irrelevant(weighted_patches, t)\n # sample new training data\n training_data = random_sample_weighted_patches(weighted_patches, training_set_size)\n if len(training_data) == 0:\n print \"no more training data!\"\n break\n toc = time.clock()\n print toc - tic\n print self","def probs_for_breeds_h5(breed_predictions):\n predictions = []\n for (x), value in np.ndenumerate(breed_predictions[0]):\n predictions.append([x[0], str(dog_names[x[0]]), value])\n sorted_predictions = sorted(predictions, key=itemgetter(2), reverse=True)\n for prediction in sorted_predictions[:5]:\n print dog_names[prediction[0]] + ': ' + str(prediction[2])","def compute_recall(data, num_labels = 4): \n \n # Declarating list to store results\n recalls = []\n \n for instance in data:\n \n # Declarating list to store individual results\n instance_recalls = []\n \n for i in np.arange(num_labels):\n \n # Computing and storing accuracy for each class\n instance_recalls.append(recall_score(instance[:, 2 + i], instance[:, 2 + i + 4]))\n \n # Storing mean results of the instance\n recalls.append(np.mean(instance_recalls))\n \n # Returning mean of all results\n return np.mean(recalls)","def test_200_boosted_goal_difference_for_home_models_with_thresholds(self):\n\n def create_model_fn(fn_team: str):\n team_stat = Stats.n_sample_stats_for_team(cursor=db_in_cursor,\n team=fn_team,\n last_sample_date=self.model_date,\n n_samples=self.num_samples,\n normalize_by_matches=True)\n\n\n return FeatureModel(\n input_data=[self.home_boost + team_stat.goal_diff, team_stat.goal_diff],\n id=team_stat.team_name\n )\n\n\n for match_date in played_home_OR_away_before_dates:\n ####\n # Build model up to the day before the match\n ####\n self.home_boost = 0.72\n self.model_date = match_date - timedelta(days=1)\n self.num_samples = num_matches_in_season\n\n models: {str: FeatureModel} = FeatureModel.create_models_for_all_teams(\n model_making_fn=create_model_fn, entities=teams)\n\n self.persist_models(model_gen_date=self.model_date, model_description=self.shortDescription(), models=models)\n\n self.make_and_store_predictions_for_date(match_date=match_date, models=models, draw_range=(0.3, 0.9))","def xgboost_cv(self, nsplits: int = 5) -> (float, float, float):\r\n x_train, x_test, y_train, y_test = train_test_split(self.x, self.y, test_size=0.2)\r\n params = {\r\n \"max_depth\": [2, 3, 5, 8],\r\n \"eta\": [0.01, 0.05, 0.1, 0.15, 0.2],\r\n \"objective\": ['binary:logistic'],\r\n \"sumsample\": [0.5, 0.7, 1],\r\n \"colsample_bytree\": [0.5, 0.7, 1],\r\n \"n_estimators\": [50, 100, 200, 500],\r\n }\r\n \"\"\"\r\n fit_params = {\r\n \"early_stopping_rounds\": 20,\r\n \"eval_metric\": \"error\",\r\n \"eval_set\": [(x_test, y_test)]\r\n }\r\n \"\"\"\r\n model = xgb.XGBClassifier()\r\n gridcv = GridSearchCV(model, params, cv=nsplits)\r\n gridcv.fit(x_train, y_train) # , **fit_params)\r\n best_params = gridcv.best_params_\r\n cv = KFold(n_splits=nsplits)\r\n acc_result = []\r\n for train, test in cv.split(self.x):\r\n x_train = self.x[train, :]\r\n x_test = self.x[test, :]\r\n y_train = self.y[train]\r\n y_test = self.y[test]\r\n model = xgb.XGBClassifier(**best_params).fit(x_train, y_train)\r\n \"\"\"\r\n x_t, x_v, y_t, y_v = train_test_split(x_train, y_train, test_size=0.2)\r\n model = xgb.XGBClassifier(**best_params).fit(x_t, y_t, eval_metric=\"error\", eval_set=[(x_v, y_v)],\r\n early_stopping_rounds=20)\r\n \"\"\"\r\n y_predict = model.predict(x_test)\r\n acc_result.append(binary_acc(y_test, y_predict))\r\n return np.mean(acc_result), np.std(acc_result), best_params","def compute_strategies_given_max_winning_bid(max_winning_bid, bidders):\r\n bid_start_points = [[-1.0] * len(bidder.values) for bidder in bidders]\r\n bid_end_points = [[-1.0] * len(bidder.values) for bidder in bidders]\r\n F_jump_points = [[(max_winning_bid, 1.0)] for _ in range(len(bidders))]\r\n\r\n # current state\r\n is_active = [0] * len(bidders)\r\n remaining_prob = [-1.0] * len(bidders)\r\n cur_bid = max_winning_bid\r\n cur_value_idx = [len(bidder.values) - 1 for bidder in bidders]\r\n\r\n def cur_value(bidder_idx):\r\n if cur_value_idx[bidder_idx] >= 0:\r\n return bidders[bidder_idx].values[cur_value_idx[bidder_idx]]\r\n else:\r\n return None\r\n\r\n def next_candidate():\r\n \"\"\"the next bidder to enter the bidding set\"\"\"\r\n candidate_bidder = -1\r\n candidate_value = -1\r\n for n in range(len(bidders)):\r\n if (is_active[n] == 0 and cur_value(n) is not None\r\n and cur_value(n) > max(candidate_value, cur_bid)):\r\n candidate_value = bidders[n].values[cur_value_idx[n]]\r\n candidate_bidder = n\r\n return candidate_value, candidate_bidder\r\n\r\n while True:\r\n # compute bidding set\r\n max_inactive_value, entering_bidder = next_candidate()\r\n while entering_bidder >= 0:\r\n active_values = [cur_value(j) for j in range(len(bidders)) if is_active[j] == 1]\r\n if ((sum(is_active) < 2 or\r\n h(cur_bid, cur_value(entering_bidder), active_values) >= 0) and\r\n not max_inactive_value > cur_bid > max_inactive_value - 1e-8):\r\n is_active[entering_bidder] = 1\r\n bid_start_points[entering_bidder][cur_value_idx[entering_bidder]] = cur_bid\r\n remaining_prob[entering_bidder] = bidders[entering_bidder].prob[cur_value_idx[entering_bidder]]\r\n max_inactive_value, entering_bidder = next_candidate()\r\n else:\r\n break\r\n\r\n # terminates computation\r\n if sum(is_active) < 2:\r\n for i in range(len(bidders)):\r\n if is_active[i] == 1:\r\n bid_end_points[i][cur_value_idx[i]] = cur_bid\r\n break\r\n\r\n # compute next change point\r\n exiting_criteria = H\r\n exp_exiting_criteria = exp_H\r\n change_points = [-1e8] * len(bidders)\r\n active_values = [cur_value(j) for j in range(len(bidders)) if is_active[j] == 1 and cur_value(j) is not None]\r\n for i in range(len(bidders)):\r\n if cur_value(i) is None:\r\n continue\r\n if is_active[i] == 0:\r\n try:\r\n change_points[i] = optimize.brentq(\r\n lambda x: h(x, cur_value(i), active_values, poly_form=True),\r\n -1e8,\r\n cur_bid)\r\n except ValueError:\r\n change_points[i] = -1e8\r\n else:\r\n if sum(bidders[i].prob[:cur_value_idx[i]]) == 0:\r\n change_points[i] = -1e8\r\n else:\r\n try:\r\n change_points[i] = optimize.brentq(\r\n lambda x: (exiting_criteria(cur_bid, cur_value(i), active_values) -\r\n exiting_criteria(x, cur_value(i), active_values) -\r\n (np.log(sum(bidders[i].prob[:cur_value_idx[i]]) + remaining_prob[i]) -\r\n np.log(sum(bidders[i].prob[:cur_value_idx[i]])))),\r\n -1e8,\r\n cur_bid)\r\n except ValueError:\r\n change_points[i] = -1e8\r\n\r\n # update state\r\n next_change = max(change_points)\r\n changing_bidder = np.argmax(change_points)\r\n for i in range(len(bidders)):\r\n if i == changing_bidder:\r\n continue\r\n if is_active[i] == 1:\r\n remaining_prob[i] = ((sum(bidders[i].prob[:cur_value_idx[i]]) + remaining_prob[i]) /\r\n exp_exiting_criteria(cur_bid, cur_value(i), active_values) *\r\n exp_exiting_criteria(next_change, cur_value(i), active_values) -\r\n sum(bidders[i].prob[:cur_value_idx[i]]))\r\n if np.abs(remaining_prob[i]) <= 1e-8:\r\n F_jump_points[i].append((next_change, sum(bidders[i].prob[:cur_value_idx[i]])))\r\n is_active[i] = 0\r\n remaining_prob[i] = -1.0\r\n bid_end_points[i][cur_value_idx[i]] = next_change\r\n cur_value_idx[i] -= 1\r\n else:\r\n F_jump_points[i].append((next_change, sum(bidders[i].prob[:cur_value_idx[i]]) + remaining_prob[i]))\r\n else:\r\n F_jump_points[i].append((next_change, sum(bidders[i].prob[:cur_value_idx[i] + 1])))\r\n if is_active[changing_bidder] == 0: # entering the bidding set\r\n is_active[changing_bidder] = 1\r\n remaining_prob[changing_bidder] = bidders[entering_bidder].prob[cur_value_idx[entering_bidder]]\r\n bid_start_points[changing_bidder][cur_value_idx[changing_bidder]] = next_change\r\n F_jump_points[changing_bidder].append(\r\n (next_change, sum(bidders[changing_bidder].prob[:cur_value_idx[changing_bidder] + 1])))\r\n else: # exiting the bidding set\r\n is_active[changing_bidder] = 0\r\n remaining_prob[changing_bidder] = -1.0\r\n bid_end_points[changing_bidder][cur_value_idx[changing_bidder]] = next_change\r\n cur_value_idx[changing_bidder] -= 1\r\n F_jump_points[changing_bidder].append(\r\n (next_change, sum(bidders[changing_bidder].prob[:cur_value_idx[changing_bidder] + 1])))\r\n cur_bid = next_change\r\n if cur_bid <= 0.0:\r\n break\r\n solution_state = State(is_active=is_active,\r\n remaining_prob=remaining_prob,\r\n cur_bid=cur_bid,\r\n cur_value_idx=cur_value_idx)\r\n\r\n return bid_start_points, bid_end_points, F_jump_points, solution_state","def classify():\n yes_dataset = df[df[\"_class\"] == 1] # 470588\n no_dataset = df[df[\"_class\"] == 0] # 1971\n\n parameter_analysis = list()\n for criterion in np.arange(0.05, 0.91, 0.05):\n print(\"doing experiment at criterion = %s ...\" % criterion)\n rate_list = list()\n for i in range(10):\n # shuffle yes_dataset and no_dataset, so we can randomly choose 90% yes_dataset\n # + 90% no_dataset as train dataset, 10% yes_dataset + 10% no_dataset as test dataset\n yes_index = yes_dataset.index.tolist()\n random.shuffle(yes_index)\n no_index = no_dataset.index.tolist()\n random.shuffle(no_index)\n \n # concatenate 90%yes + 90%no, 10%yes + 10%no\n train = pd.concat([\n yes_dataset.loc[yes_index[:1774], :],\n no_dataset.loc[no_index[:423530], :]\n ])\n test = pd.concat([\n yes_dataset.loc[yes_index[1774:], :],\n no_dataset.loc[no_index[423530:], :]\n ]) \n \n # split data and label\n train_data, train_label = (train[[\"Revenue.Code\", \n \"Service.Code\", \n \"Procedure.Code\", \n \"Diagnosis.Code\", \n \"Subscriber.Index\"]], \n train[\"_class\"])\n test_data, test_label = (test[[\"Revenue.Code\", \n \"Service.Code\", \n \"Procedure.Code\", \n \"Diagnosis.Code\", \n \"Subscriber.Index\"]], \n test[\"_class\"])\n \n # apply classifier\n clf = GaussianNB()\n clf.fit(train_data, train_label)\n probability = clf.predict_proba(test_data).T[1]\n \n result = pd.DataFrame()\n result[\"_class\"] = test_label\n result[\"_predict\"] = probability >= criterion\n \n result_yes = result[result[\"_class\"] == 1]\n yes_yes_rate = sum(result_yes[\"_class\"] == result_yes[\"_predict\"])/len(result_yes[\"_predict\"])\n \n result_no = result[result[\"_class\"] == 0]\n no_no_rate = sum(result_no[\"_class\"] == result_no[\"_predict\"])/len(result_no[\"_predict\"])\n \n rate_list.append((yes_yes_rate, no_no_rate))\n\n rate_list = pd.DataFrame(rate_list)\n yes_yes_rate, no_no_rate = rate_list.mean()[0], rate_list.mean()[1]\n parameter_analysis.append((criterion, yes_yes_rate, no_no_rate))\n \n # save data to excel spreadsheet\n parameter_analysis = pd.DataFrame(parameter_analysis, columns=[\"criterion\", \"yes_yes_rate\", \"no_no_rate\"])\n writer = pd.ExcelWriter(\"parameter_analysis.xlsx\")\n parameter_analysis.to_excel(writer, \"parameter_analysis\", index=False)\n writer.save()","def ensemble(scores):\r\n c = Counter ()\r\n for probs in zip (scores):\r\n idx = int (np.argmax (np.array (probs)))\r\n c.update ([idx])\r\n best = c.most_common (1)[0][0]\r\n return best","def run_classifier_bayes_statistics(mode, image_type, indices, percentage, smoothing, debug):\n start = time.time()\n dat = train_naive_bayes(image_type, smoothing, percentage)\n end = time.time()\n output = classify_naive_bayes(dat, mode, indices, debug)\n return {'accuracy': check_correctness_statistics(output, mode, image_type), 'runtime': (end-start)}","def tuneRandomForest(train_set):\n\n auc_score = make_scorer(roc_auc_score)\n acc = make_scorer(accuracy_score)\n\n train_set = pd.read_csv(train_set, sep=\"\\t\", low_memory=False)\n\n train_output = train_set[\"output\"].values\n train_features = train_set[train_set.columns.drop([\"labels\", \"output\"])].values\n\n #X_train, X_test, y_train, y_test = train_test_split(train_features, train_output, test_size=0.20)\n\n # define parameters to be optimized\n parameters = {\n 'n_estimators': [int(x) for x in range(200, 3000, 300)],\n 'max_features': ['log2', 'sqrt', \"auto\"],\n 'criterion': [\"gini\", \"entropy\"],\n }\n #plotGrid(parameters, script_path + \"/results/GridSearchPlot.png\")\n\n scores = ['precision', 'recall', 'f1', auc_score, acc] # compute efficiency based on scores\n for score in scores:\n print(\"# Tuning hyper-parameters for %s\" % score)\n\n tune_search = GridSearchCV(\n RandomForestClassifier(n_jobs=-1),\n parameters,\n scoring=score\n )\n #tune_search.fit(X_train, y_train)\n tune_search.fit(train_features, train_output)\n print(tune_search.best_params_)\n\n means = tune_search.cv_results_['mean_test_score']\n stds = tune_search.cv_results_['std_test_score']\n for mean, std, params in zip(means, stds, tune_search.cv_results_['params']):\n print(\"%0.3f (+/-%0.03f) for %r\" % (mean, std * 2, params))\n\n #y_true, y_pred = y_test, tune_search.predict(X_test)\n # print(classification_report(y_true, y_pred))\n #print()","def postprocess(scores, classes, bboxes, iou_threshold=0.3, score_threshold=0.5):\n n = len(scores)\n \n det_num = 0\n det_classes = [] \n det_scores = []\n det_bboxes = []\n\n idx = np.argsort(scores)[::-1]\n sorted_scores = scores[idx]\n sorted_bboxes = bboxes[idx]\n sorted_classes = classes[idx]\n\n top_k_ids = []\n i = 0\n\n while i < n:\n if sorted_scores[i] < score_threshold:\n break\n\n top_k_ids.append(i)\n det_num += 1\n det_scores.append(sorted_scores[i])\n det_bboxes.append(sorted_bboxes[i])\n det_classes.append(sorted_classes[i])\n i += 1\n\n while i < n:\n tiled_bbox_i = np.tile(sorted_bboxes[i], (det_num, 1)) \n flags = (sorted_classes[top_k_ids]==sorted_classes[i])*1.0 \n ious, iofs, ioss = iou_bbox(tiled_bbox_i, sorted_bboxes[top_k_ids]) \n max_iou = np.max(ious) \n # max_iof = np.max(iofs*flags) \n # max_ios = np.max(ioss*flags) \n # temp = np.max((max_iof, max_ios))\n if max_iou > iou_threshold:\n i += 1\n else:\n break\n\n return det_num, np.array(det_scores, np.float32), np.array(det_classes, np.int32), np.array(det_bboxes, np.int32)","def _train_clf_opt(self, predictions):\n\n X = self._construct_clf_opt_X(predictions)\n y = predictions['ytruth']\n X, y = self._check_train_labels(X, y)\n\n # self.clf_opt.n_estimators += 10 # This was for warm-start\n self.clf_opt.fit(X, y)\n self.clf_opt_trained = True\n\n if self.aim is not None:\n ypred = self._predict_proba(self.clf_opt, X=X)\n ybl = self.bl_predict(n_samples=len(X))\n x = minimize(self._opt_round_cutoff,\n np.array([self.round_cutoff if self.round_cutoff is not None else 0.5]),\n (y, ypred, ybl),\n method='cobyla',\n options={'rhobeg': 0.1}).x[0]\n self.round_cutoff_history.append(x)\n self.round_cutoff = np.median(self.round_cutoff_history)\n print('Optimal [%s] round_cutoff=%.4f' % (self.aim, self.round_cutoff))\n\n return","def compute_splits(feature_df, target_col, max_num_splits):\n tree_estimator = DecisionTreeClassifier(max_leaf_nodes=max_num_splits+1,\n class_weight='balanced',\n random_state=1407)\n\n tree_estimator.fit(feature_df, target_col)\n thresholds = tree_estimator.tree_.threshold[tree_estimator.tree_.children_left != _tree.TREE_LEAF]\n return sorted(thresholds)","def build_classifiers(self):\n classifiers = []\n for index, view in enumerate(BayesianKneighborClassifier.views):\n knn = KNeighborsClassifier(n_neighbors=BayesianKneighborClassifier.best_neighbours[index])\n BayesianKneighborClassifier.update_current_data(self, index)\n X_train, X_test, y_train, y_test = BayesianKneighborClassifier.split_test_and_train_data\\\n (self, test_size=0.3)\n knn.fit(X_train, y_train)\n classifiers.append(knn)\n return classifiers","def eval_metrics_for_multiclass(self, predicted_answers):\n total_correct_in_all = 0\n total_pred_in_all = len(predicted_answers)\n # initial a dict for total correct in topK counting.\n total_correct_in_topK = dict([(i, 0) for i in self.topK_list])\n total_pred_in_topK = dict([(i, 0) for i in self.topK_list])\n max_topK = max(self.topK_list)\n label_pred = []\n label_true = []\n label_weights = []\n digits = 3\n metrics = {}\n\n for e_id, sample in predicted_answers.iteritems():\n # get all correct ids\n correct_label_indices = sample['correct_labels']\n # current case, we only have a majority lable for the correct label\n label_true.append(correct_label_indices[0])\n # counting all correct for each sample\n total_correct_in_all += len(correct_label_indices)\n # select topK\n sorted_probs_max_topK = sorted(sample['pred_probs'], reverse=True, key=lambda x: x['prob'])[:max_topK]\n top1_pred = sorted_probs_max_topK[0]\n label_pred.append(top1_pred['label_index'])\n\n # for all topK predictions\n for i in range(len(sorted_probs_max_topK)):\n pred = sorted_probs_max_topK[i]\n for topK in self.topK_list:\n if i >= topK:\n continue\n else:\n total_pred_in_topK[topK] += 1\n if pred['label_index'] in correct_label_indices:\n total_correct_in_topK[topK] += 1\n\n if total_correct_in_all != 0:\n # recall@K\n recall_at_K = dict([(k, total_correct_in_topK[k] / (total_correct_in_all * 1.0)) for k in self.topK_list])\n # assign recall@K into metrics\n for k, v in recall_at_K.items():\n # Jie\n # 1 means the greater the better.\n # -1 means the smaller the better.\n metrics['R@{}'.format(k)] = (1, v)\n\n self.logger.info('total_correct_in_all = {}, correct_in_topK = {}, recall@K = {}'.format(total_correct_in_all, sorted(total_correct_in_topK.items()), sorted(recall_at_K.items())))\n # here return all the p,r,f for each label, then we compute the micro average later.\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\n total_s = np.sum(s)\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\n target_names = self.classes\n name_width = max(len(cn) for cn in target_names)\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\n\n headers = [\"precision\", \"recall\", \"f1-score\", \"support\"]\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\n report = head_fmt.format(u'', *headers, width=width)\n report += u'\\n\\n'\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\n'\n rows = zip(target_names, p, r, f1, s)\n for row in rows:\n label_weights.append(row[4])\n report += row_fmt.format(*row, width=width, digits=digits)\n metrics['P_{}'.format(row[0])] = (1, row[1])\n metrics['R_{}'.format(row[0])] = (1, row[2])\n metrics['F1_{}'.format(row[0])] = (1, row[3])\n report += u'\\n'\n\n # compute macro averages\n p_macro = np.average(p, weights = None)\n r_macro = np.average(r, weights = None)\n f1_macro = np.average(f1, weights = None)\n metrics['P_{}'.format(\"macro\")] = (1, p_macro)\n metrics['R_{}'.format(\"macro\")] = (1, r_macro)\n metrics['F1_{}'.format(\"macro\")] = (1, f1_macro)\n report += row_fmt.format(last_lines_heading[0],\n p_macro,\n r_macro,\n f1_macro,\n total_s,\n width=width, digits=digits)\n\n # compute weighted macro average\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\n p_weighted_average = np.average(p, weights = label_weights)\n r_weighted_average = np.average(r, weights = label_weights)\n f1_weighted_average = np.average(f1, weights = label_weights)\n metrics['P_{}'.format(\"weighted_macro\")] = (1, p_weighted_average)\n metrics['R_{}'.format(\"weighted_macro\")] = (1, r_weighted_average)\n metrics['F1_{}'.format(\"weighted_macro\")] = (1, f1_weighted_average)\n report += row_fmt.format(last_lines_heading[1],\n p_weighted_average,\n r_weighted_average,\n f1_weighted_average,\n total_s,\n width=width, digits=digits)\n # micro average\n metrics['P_{}'.format(\"micro\")] = (1, p_micro)\n metrics['R_{}'.format(\"micro\")] = (1, r_micro)\n metrics['F1_{}'.format(\"micro\")] = (1, f1_micro)\n report += row_fmt.format(last_lines_heading[2],\n p_micro,\n r_micro,\n f1_micro,\n total_s,\n width=width, digits=digits)\n\n self.logger.info(\"P,R,F1 report as follows:\\n {}\".format(report))\n # only plot it at dev and test time, not during training.\n if self.gen_confusing_matrix:\n\n self.logger.info(\"Generate confusing matrix photo.\")\n # Compute confusion matrix\n conf_matrix = confusion_matrix(label_true, label_pred)\n np.set_printoptions(precision=2)\n\n # Plot non-normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d',\n title='Confusion matrix, without normalization')\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\n plt.savefig(wo_norm_fig_path)\n\n # Plot normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d', normalize=True,\n title='Normalized confusion matrix')\n\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\n plt.savefig(norm_fig_path)\n\n else:\n self.logger.warn('invalid total_correct_in_all')\n\n return metrics","def balance_dataset_weighting(instances):\n factors = get_balancing_weight_factors(instances)\n new_instances = [ (features, classification, w * factors[classification]) \n for features, classification, w in instances ]\n return new_instances","def get_score(data, labels, fold_pairs, name, model, param, numTopVars,\r\n rank_per_fold=None, parallel=True, rand_iter=-1):\r\n assert isinstance(name, str)\r\n logging.info(\"Classifying %s\" % name)\r\n ksplit = len(fold_pairs)\r\n# if name not in NAMES:\r\n# raise ValueError(\"Classifier %s not supported. \"\r\n# \"Did you enter it properly?\" % name)\r\n\r\n # Redefine the parameters to be used for RBF SVM (dependent on\r\n # training data)\r\n if \"SGD\" in name:\r\n param[\"n_iter\"] = [25] # [np.ceil(10**3 / len(fold_pairs[0][0]))]\r\n classifier = get_classifier(name, model, param, rand_iter=rand_iter)\r\n \r\n if name == \"RBF SVM\": #This doesn't use labels, but looks as ALL data\r\n logging.info(\"RBF SVM requires some preprocessing.\"\r\n \"This may take a while\")\r\n #\r\n is_data_computed_gamma = True\r\n #\r\n if not is_data_computed_gamma:\r\n # Sahil commented the code below that computes the gamma choices from data.\r\n # The computed gamma choices seem too low thereby making SVM very slow. Instead, trying out fixed values.\r\n print param\r\n gamma = param['gamma']\r\n gamma = np.array(gamma)\r\n print 'gamma', gamma\r\n else:\r\n #Euclidean distances between samples\r\n # sahil switched from the first call to second one for computing the dist as the first one is giving error.\r\n # dist = pdist(StandardScaler().fit(data), \"euclidean\").ravel()\r\n dist = pdist(RobustScaler().fit_transform(data), \"euclidean\").ravel()\r\n print 'dist', dist\r\n #Estimates for sigma (10th, 50th and 90th percentile)\r\n sigest = np.asarray(np.percentile(dist, [10, 50, 90]))\r\n print 'sigest', sigest\r\n #Estimates for gamma (= -1/(2*sigma^2))\r\n gamma = 1./(2*sigest**2)\r\n print 'gamma', gamma\r\n #\r\n #\r\n #Set SVM parameters with these values\r\n # sahil changed the code a bit to remove a bug\r\n # param = [{\"kernel\": [\"rbf\"],\r\n # \"gamma\": gamma.tolist(),\r\n # \"C\": np.logspace(-2,2,5).tolist()}]\r\n param = {\"kernel\": [\"rbf\"],\r\n \"gamma\": gamma.tolist(),\r\n \"C\": np.logspace(-2, 2, 5).tolist()}\r\n # if name not in [\"Decision Tree\", \"Naive Bayes\"]:\r\n if param:\r\n if hasattr(classifier,'param_grid'): \r\n # isinstance(classifier, GridSearchCV):\r\n print 'param', param\r\n N_p = np.prod([len(l) for l in param.values()])\r\n elif isinstance(classifier, RandomizedSearchCV):\r\n N_p = classifier.n_iter\r\n else:\r\n N_p = 1\r\n# is_cv = isinstance(classifier, GridSearchCV) or \\\r\n# isinstance(classifier, RandomizedSearchCV)\r\n# print('Name: {}, ksplit: {}, N_p: {}'.format(name, ksplit, N_p))\r\n if (not parallel) or ksplit <= N_p or \\\r\n (name == \"Random Forest\") or (\"SGD\" in name):\r\n logging.info(\"Attempting to use grid search...\")\r\n classifier.n_jobs = PROCESSORS\r\n classifier.pre_dispatch = 1 # np.floor(PROCESSORS/24)\r\n allConfMats = []\r\n allTotalErrs = []\r\n allFittedClassifiers = []\r\n for i, fold_pair in enumerate(fold_pairs):\r\n confMats = []\r\n totalErrs = []\r\n fitted_classifiers = []\r\n logging.info(\"Classifying a %s the %d-th out of %d folds...\"\r\n % (name, i+1, len(fold_pairs)))\r\n if rank_per_fold is not None:\r\n rankedVars = rank_per_fold[i]\r\n else:\r\n rankedVars = np.arange(data.shape[1])\r\n #\r\n for numVars in numTopVars:\r\n logging.info('Classifying for top %i variables' % numVars)\r\n #\r\n # print 'rankedVars', rankedVars\r\n #\r\n confMat, totalErr, fitted_classifier = classify(data[:, rankedVars[:numVars]],\r\n labels,\r\n fold_pair,\r\n classifier)\r\n confMats.append(confMat)\r\n totalErrs.append(totalErr)\r\n fitted_classifiers.append(fitted_classifier)\r\n # recheck the structure of area and fScore variables\r\n allConfMats.append(confMats)\r\n allTotalErrs.append(totalErrs)\r\n allFittedClassifiers.append(fitted_classifiers)\r\n else:\r\n print 'parallel computing going on (debug Sahil ...) ..........................'\r\n #\r\n classifier.n_jobs = PROCESSORS\r\n logging.info(\"Multiprocessing folds for classifier {}.\".format(name))\r\n pool = Pool(processes=min(ksplit, PROCESSORS))\r\n out_list = pool.map(per_split_classifier(data, labels, classifier,\r\n numTopVars),\r\n zip(rank_per_fold, fold_pairs))\r\n pool.close()\r\n pool.join()\r\n #allConfMats = [el[0] for el in out_list]\r\n #allTotalErrs = [el[1] for el in out_list]\r\n #allFittedClassifiers = [el[2] for el in out_list]\r\n allConfMats, allTotalErrs, allFittedClassifiers = tuple(zip(*out_list))\r\n return classifier, allConfMats, allTotalErrs, allFittedClassifiers","def evaluate(self, Estimator, params):\n assert hasattr(Estimator, 'fit'),\\\n \"Estimator must implement the fit method\"\n assert hasattr(Estimator, 'predict'),\\\n \"Estimator must implement the predict method\"\n # Initialize Estimators\n models = [Estimator(param) for param in params]\n ac = list()\n for idx, (search, hold_out) in enumerate(self.cv):\n if idx >= self.max_outer:\n break\n cv = StratifiedKFold(y=self.b[search], n_folds=self.k_folds-1)\n for jdx, (train, test) in enumerate(cv):\n if jdx >= self.max_inner:\n break\n scores = [self._score(model, train, test) for model in models]\n ac.append(self._score(models[np.argmax(scores)], search, hold_out))\n return np.mean(ac)","def evaluate_prediction_BoW(vectorizer, classifier, test_data):\n \n data = (test_data[k][0] for k in range(len(test_data))) # generator for the train data\n data_features = vectorizer.transform(data)\n predictions = classifier.predict(data_features)\n target = [test_data[k][1] for k in range(len(test_data))]\n \n return accuracy_score(target, predictions)","def run(self):\n if self.pb.xvalEN and not self.isXvalMain:\n dt = np.ones(self.pb.total_exam_no,\n dtype=\"float32\") / self.train_exam_no\n dt[self.val_indices] = 0.0\n else:\n dt = np.ones(self.pb.total_exam_no,\n dtype=\"float32\") / self.pb.total_exam_no\n\n val = np.zeros(8,dtype=\"float32\")-1\n boosting = None\n wl = None\n if self.pb.algorithm == 'conf-rated':\n boosting = ConfidenceRated(self)\n wl = ConfidenceRatedWL(self)\n elif self.pb.algorithm == 'adaboost':\n boosting = AdaBoost(self)\n wl = AdaBoostWL(self)\n elif self.pb.algorithm == 'adaboost-fast':\n boosting = AdaBoostFast(self)\n wl = AdaBoostFastWL(self)\n elif self.pb.algorithm == 'rankboost':\n boosting = RankBoost(self)\n wl = ConfidenceRatedWL(self)\n elif self.pb.algorithm == 'rankboost-fast':\n boosting = RankBoost(self)\n wl = AdaBoostFastWL(self)\n else:\n raise Exception(\"Unknown Boosting Algorithm\")\n \n for r in range(self.pb.rounds):\n tree = wl.run(dt)\n dt = boosting.run(dt = dt,\n r = r,\n tree = tree)\n \n if self.isXvalMain:\n boosting.finalize()\n \n \"\"\"Sync the predictions and save them to a file\"\"\"\n if self.pb.isLeader:\n if self.pb.xvalEN and not self.isXvalMain:\n val_predictions = boosting.get_val_predictions()\n hypotheses = boosting.get_hypotheses()\n np.savez(self.out_fp,\n val_predictions = val_predictions,\n hypotheses = hypotheses,\n )\n if self.pb.testEN and self.isXvalMain:\n train_predictions = boosting.get_train_predictions()\n test_predictions = boosting.get_test_predictions()\n hypotheses = boosting.get_hypotheses()\n np.savez(self.out_fp,\n train_predictions = train_predictions,\n test_predictions = test_predictions,\n hypotheses = hypotheses,\n )\n if not self.pb.testEN and self.isXvalMain:\n train_predictions = boosting.get_train_predictions()\n hypotheses = boosting.get_hypotheses()\n np.savez(self.out_fp,\n train_predictions = train_predictions,\n hypotheses = hypotheses,\n )","def _do_grid_search_round(self) -> Dict[str, Dict[str, Any]]:\n\n cfg = self.cfg_\n\n # Get the data to use, vectorizing the sample feature dictionaries\n y_train = list(self._generate_samples(self.grid_search_ids_, 'y'))\n X_train = self._vectorize_and_sparsify_data(self.gs_vec_,\n self.grid_search_ids_)\n\n # Feature selection\n if cfg.feature_selection_percentile != 1.0:\n loginfo('Removing {0}% of the features during grid search round...'\n .format(100 - 100*cfg.feature_selection_percentile))\n X_train = \\\n (SelectPercentile(chi2,\n percentile=100*cfg.feature_selection_percentile)\n .fit_transform(X_train, y_train))\n\n # Make a `StratifiedKFold` object using the list of labels\n # NOTE: This will effectively redistribute the samples in the\n # various grid search folds, but it will maintain the\n # distribution of labels. Furthermore, due to the use of the\n # `RandomState` object, it should always happen in the exact\n # same way.\n prng = np.random.RandomState(12345)\n gs_cv_folds_ = StratifiedKFold(y=y_train,\n n_folds=self.data_.grid_search_folds,\n shuffle=True,\n random_state=prng)\n\n # Iterate over the learners/parameter grids, executing the grid search\n # cross-validation for each\n loginfo('Doing a grid search cross-validation round with {0} folds for'\n ' each learner and each corresponding parameter grid.'\n .format(self.data_.grid_search_folds))\n n_jobs_learners = ['Perceptron', 'SGDClassifier',\n 'PassiveAggressiveClassifier']\n learner_gs_cv_params_ = {}\n for learner, learner_name, param_grids in zip(self.learners_,\n self.learner_names_,\n cfg.param_grids):\n\n loginfo('Grid search cross-validation for {0}...'\n .format(learner_name))\n\n # If the learner is `MiniBatchKMeans`, set the `batch_size`\n # parameter to the number of training samples\n if learner_name == 'MiniBatchKMeans':\n for param_grid in param_grids:\n param_grid['batch_size'] = [len(y_train)]\n\n # If learner is of any of the learner types in\n # `n_jobs_learners`, add in the `n_jobs` parameter specified\n # in the config (but only do so if that `n_jobs` value is\n # greater than 1 since it won't matter because 1 is the\n # default, anyway)\n if cfg.n_jobs > 1:\n if learner_name in n_jobs_learners:\n for param_grid in param_grids:\n param_grid['n_jobs'] = [cfg.n_jobs]\n\n # Make `GridSearchCV` instance\n folds_diff = cfg.grid_search_folds - self.data_.grid_search_folds\n if (self.data_.grid_search_folds < 2\n or folds_diff/cfg.grid_search_folds > 0.25):\n msg = ('Either there weren\\'t enough folds after collecting '\n 'data (via `ExperimentalData`) to do the grid search '\n 'round or the number of folds had to be reduced to such'\n ' a degree that it would mean a +25\\% reduction in the '\n 'total number of folds used during the grid search '\n 'round.')\n logerr(msg)\n raise ValueError(msg)\n gs_cv = GridSearchCV(learner(),\n param_grids,\n cv=gs_cv_folds_,\n scoring=self._resolve_objective_function())\n\n # Do the grid search cross-validation\n gs_cv.fit(X_train, y_train)\n learner_gs_cv_params_[learner_name] = gs_cv.best_params_\n del gs_cv\n\n del X_train\n del y_train\n\n return learner_gs_cv_params_","def compute_score_fast(verbose=1):\n res = []\n\n batch = math.ceil(len(train) / LINEAR_ASSIGNMENT_SEGMENT_SIZE)\n for start in range(0, len(train), batch):\n end = min(len(train), start + batch)\n train_batch = train[start:end]\n\n features = branch_model.predict_generator(FeatureGen(train_batch, verbose=verbose), max_queue_size=12, workers=6, verbose=0)\n score = head_model.predict_generator(ScoreGen(features, verbose=verbose), max_queue_size=12, workers=6, verbose=0)\n score = score_reshape(score, features)\n\n res.append(score)\n\n return res","def train_w_batch_boost(self, out_tag='my_lstm', save=True, auc_threshold=0.01):\n\n self.create_train_valid_set()\n\n #paramaters that control batch size\n best_auc = 0.5\n #current_batch_size = 1024\n current_batch_size = 64\n #max_batch_size = 50000\n max_batch_size = 50000\n\n #keep track of epochs for plotting loss vs epoch, and for getting best model\n epoch_counter = 0 \n best_epoch = 1 \n\n keep_training = True\n\n while keep_training:\n epoch_counter += 1\n print('beginning training iteration for epoch {}'.format(epoch_counter))\n self.train_network(epochs=1, batch_size=current_batch_size)\n\n self.save_model(epoch_counter, out_tag)\n val_roc = self.compute_roc(batch_size=current_batch_size, valid_set=True) #FIXME: what is the best BS here? final BS from batch boost... initial BS? current BS??\n\n #get average of validation rocs and clear list entries \n improvement = ((1-best_auc) - (1-val_roc)) / (1-best_auc)\n\n #FIXME: if the validation roc does not improve after n bad \"epochs\", then update the batch size accordingly. Rest bad epochs to zero each time the batch size increases, if it does\n\n #do checks to see if batch size needs to change etc\n if improvement > auc_threshold:\n print('Improvement in (1-AUC) of {:.4f} percent. Keeping batch size at {}'.format(improvement*100, current_batch_size))\n best_auc = val_roc\n best_epoch = epoch_counter\n elif current_batch_size*4 < max_batch_size:\n print('Improvement in (1-AUC) of only {:.4f} percent. Increasing batch size to {}'.format(improvement*100, current_batch_size*4))\n current_batch_size *= 4\n if val_roc > best_auc: \n best_auc = val_roc\n best_epoch = epoch_counter\n elif current_batch_size < max_batch_size: \n print('Improvement in (1-AUC) of only {:.4f} percent. Increasing to max batch size of {}'.format(improvement*100, max_batch_size))\n current_batch_size = max_batch_size\n if val_roc > best_auc: \n best_auc = val_roc\n best_epoch = epoch_counter\n elif improvement > 0:\n print('Improvement in (1-AUC) of only {:.4f} percent. Cannot increase batch further'.format(improvement*100))\n best_auc = val_roc\n best_epoch = epoch_counter\n else: \n print('AUC did not improve and batch size cannot be increased further. Stopping training...')\n keep_training = False\n\n if epoch_counter > self.max_epochs:\n print('At the maximum number of training epochs ({}). Stopping training...'.format(self.max_epochs))\n keep_training = False\n best_epoch = self.max_epochs\n \n print 'best epoch was: {}'.format(best_epoch)\n print 'best validation auc was: {}'.format(best_auc)\n self.val_roc = best_auc\n \n\n #delete all models that aren't from the best training. Re-load best model for predicting on test set \n for epoch in range(1,epoch_counter+1):\n if epoch is not best_epoch:\n os.system('rm {}/models/{}_model_epoch_{}.hdf5'.format(os.getcwd(), out_tag, epoch))\n os.system('rm {}/models/{}_model_architecture_epoch_{}.json'.format(os.getcwd(), out_tag, epoch))\n os.system('mv {0}/models/{1}_model_epoch_{2}.hdf5 {0}/models/{1}_model.hdf5'.format(os.getcwd(), out_tag, best_epoch))\n os.system('mv {0}/models/{1}_model_architecture_epoch_{2}.json {0}/models/{1}_model_architecture.json'.format(os.getcwd(), out_tag, best_epoch))\n\n #reset model state and load in best weights\n with open('{}/models/{}_model_architecture.json'.format(os.getcwd(), out_tag), 'r') as model_json:\n best_model_architecture = model_json.read()\n self.model = keras.models.model_from_json(best_model_architecture)\n self.model.load_weights('{}/models/{}_model.hdf5'.format(os.getcwd(), out_tag))\n\n if not save:\n os.system('rm {}/models/{}_model_architecture.json'.format(os.getcwd(), out_tag))\n os.system('rm {}/models/{}_model.hdf5'.format(os.getcwd(), out_tag))","def calculate_accuracy(ground_truth_object_list, pred_object_list):\n\n ground_truth_list = np.zeros((1,10))\n pred_list = np.zeros((1,10))\n \n for gt_index in range(len(ground_truth_object_list)):\n \n intClass_ground_truth = classMappingDict[ground_truth_object_list[gt_index]['name']]\n ground_truth_list[0][intClass_ground_truth] = ground_truth_list[0][intClass_ground_truth] + 1\n\n for pred_index in range(len(pred_object_list)):\n\n intClass_pred = classMappingDict[pred_object_list[pred_index]['name']]\n pred_list[0][intClass_pred] = pred_list[0][intClass_pred] + 1\n return ground_truth_list, pred_list","def find_best_classifier(classifiers, X_t, y_t, X_v, y_v, params, jobs):\n\n # Initialize result storage\n clfs_return = []\n train_scores = []\n test_scores = []\n\n # Loop through classifiers\n for classifier in classifiers:\n # Grid search, calibrate, and test the classifier\n classifier, train_score, test_score = train_calibrate_predict(\n classifier, X_t, y_t, X_v, y_v, params[classifier], jobs)\n\n # Append the result to storage\n clfs_return.append(classifier)\n train_scores.append(train_score)\n test_scores.append(test_score)\n\n # Return storage\n return clfs_return, train_scores, test_scores","def model(**params):\n N_frb = 0\n vs = []\n hs = []\n cs = []\n ncands = []\n\n for cand in candlist:\n c_res = calculate_metric_terms(\n cand, cluster_function=cluster_function, debug=False, plot=False, **params\n )\n t, frb_found, h, c, v = c_res\n vs.append(v)\n hs.append(h)\n cs.append(c)\n ncands.append(t)\n\n if frb_found:\n N_frb += 1\n\n vs = np.array(vs)\n hs = np.array(hs)\n cs = np.array(cs)\n c_avg = np.average(cs, axis=0, weights=ncands)\n h_avg = np.average(hs, axis=0, weights=ncands)\n v_avg = np.average(vs, axis=0, weights=ncands)\n recall = N_frb / len(vs)\n score = v_avg * recall\n\n return score","def update(self, round, npc, cheat_labels=None):\n with torch.no_grad():\n batch_size = 100\n ANs_num = self.get_ANs_num(round)\n logger.debug('Going to choose %d samples as anchors' % ANs_num)\n features = npc.memory\n logger.debug(\"Start to compute each sample's entropy\")\n for start in xrange(0, self.samples_num, batch_size):\n logger.progress(start, self.samples_num, 'processing %d/%d samples...')\n end = start + batch_size\n end = min(end, self.samples_num)\n preds = F.softmax(npc(features[start:end], None), 1)\n self.entropy[start:end] = -(preds * preds.log()).sum(1)\n logger.debug('Compute entropy done, max(%.2f), min(%.2f), mean(%.2f)' % (self.entropy.max(), self.entropy.min(), self.entropy.mean()))\n self.anchor_indexes = self.entropy.topk(ANs_num, largest=False)[1]\n self.instance_indexes = torch.ones_like(self.position).scatter_(0, self.anchor_indexes, 0).nonzero().view(-1)\n anchor_entropy = self.entropy.index_select(0, self.anchor_indexes)\n instance_entropy = self.entropy.index_select(0, self.instance_indexes)\n if self.anchor_indexes.size(0) > 0:\n logger.debug('Entropies of anchor samples: max(%.2f), min(%.2f), mean(%.2f)' % (anchor_entropy.max(), anchor_entropy.min(), anchor_entropy.mean()))\n if self.instance_indexes.size(0) > 0:\n logger.debug('Entropies of instance sample: max(%.2f), min(%.2f), mean(%.2f)' % (instance_entropy.max(), instance_entropy.min(), instance_entropy.mean()))\n logger.debug('Start to get the position of both anchor and instance samples')\n instance_cnt = 0\n for i in xrange(self.samples_num):\n logger.progress(i, self.samples_num, 'processing %d/%d samples...')\n if (i == self.anchor_indexes).any():\n self.position[i] = (self.anchor_indexes == i).max(0)[1]\n continue\n instance_cnt -= 1\n self.position[i] = instance_cnt\n logger.debug('Start to find %d neighbours for each anchor sample' % self.ANs_size)\n anchor_features = features.index_select(0, self.anchor_indexes)\n self.neighbours = torch.LongTensor(ANs_num, self.ANs_size)\n for start in xrange(0, ANs_num, batch_size):\n logger.progress(start, ANs_num, 'processing %d/%d samples...')\n end = start + batch_size\n end = min(end, ANs_num)\n sims = torch.mm(anchor_features[start:end], features.t())\n sims.scatter_(1, self.anchor_indexes[start:end].view(-1, 1), -1.0)\n _, self.neighbours[start:end] = sims.topk(self.ANs_size, largest=True, dim=1)\n logger.debug('ANs discovery done')\n if cheat_labels is None:\n return 0.0\n logger.debug('Start to compute ANs consistency')\n anchor_label = cheat_labels.index_select(0, self.anchor_indexes)\n neighbour_label = cheat_labels.index_select(0, self.neighbours.view(-1)).view_as(self.neighbours)\n self.consistency = (anchor_label.view(-1, 1) == neighbour_label).float().mean()\n return self.consistency","def test_220_boosted_goal_difference_for_home_models_with_various_upper_home_win_threshold(self):\n\n def create_model_fn(fn_team: str):\n team_stat = Stats.n_sample_stats_for_team(cursor=db_in_cursor,\n team=fn_team,\n last_sample_date=self.model_date,\n n_samples=self.num_samples,\n normalize_by_matches=True)\n\n\n return FeatureModel(\n input_data=[self.home_boost + team_stat.goal_diff, team_stat.goal_diff],\n id=team_stat.team_name\n )\n\n default_threshold_lower = 0.3\n default_threshold_upper = 0.9\n\n explore_range = (default_threshold_lower, 5.0)\n num_steps_wanted = 60\n step_size = (explore_range[1] - explore_range[0])/num_steps_wanted\n\n threshold_lower = default_threshold_lower\n for threshold_upper in StatsPredictionPremierLeague.crange(first=explore_range[0], test=lambda x: x <= explore_range[1],\n update=lambda x: x + step_size):\n for match_date in played_home_OR_away_before_dates:\n ####\n # Build model up to the day before the match\n ####\n self.home_boost = 0.72\n self.model_date = match_date - timedelta(days=1)\n self.num_samples = num_matches_in_season\n\n models: {str: FeatureModel} = FeatureModel.create_models_for_all_teams(\n model_making_fn=create_model_fn, entities=teams)\n\n self.persist_models(model_gen_date=self.model_date, model_description=self.shortDescription(), models=models)\n\n # variant_string = 'threshold_lower=%f, threshold_upper=%f' % (threshold_lower, threshold_upper)\n self.make_and_store_predictions_for_date(match_date=match_date, models=models, draw_range=(threshold_lower, threshold_upper),\n variants=threshold_upper)","def cal_average_kill_turns(deck):\n #Results array\n turn_results = np.zeros(NUM_SIMS)\n \n #Simulation loop\n for i in range(NUM_SIMS): \n if VERBOSE:\n print('Running simulation ' + str(i + 1)) \n turn_results[i] = cal_kill_turn(copy.deepcopy(deck))\n #End of Simulations\n \n #DETERMINE ATK\n average_kill_turn = np.average(turn_results)\n min_kill_turn = np.min(turn_results)\n max_kill_turn = np.max(turn_results)\n \n return average_kill_turn, min_kill_turn, max_kill_turn","def setUpMax(roundX):\n vals = []\n for attribute in roundX[\"attributes\"]:\n vals.append(roundX[\"attributes\"][attribute][\"gain\"])\n branch = []\n for attribute in roundX[\"attributes\"]:\n if max(vals) == roundX[\"attributes\"][attribute][\"gain\"]:\n branch.append(attribute)\n return branch","def findRFBestDepth():\n resultList = []\n BestScore = 0\n # iterate through different max_depths from 1 to 19\n for max_depth in range(1,20):\n rforest = ensemble.RandomForestClassifier(max_depth=max_depth, n_estimators=100)\n trainng_score = []\n testing_score = []\n # run 10 different cross-validation\n for index in range(10):\n # split into cross-validation sets.\n cv_data_train, cv_data_test, cv_target_train, cv_target_test = \\\n cross_validation.train_test_split(X_train, y_train, test_size=0.1)\n\n # fit the model using the cross-validation data\n # and tune parameter, such as max_depth here\n rforest = rforest.fit(cv_data_train, cv_target_train)\n trainng_score += [rforest.score(cv_data_train,cv_target_train)]\n testing_score += [rforest.score(cv_data_test,cv_target_test)]\n\n # Compute the average score for both traning and testing data\n trainng_avgScore = 1.0 * sum(trainng_score)/len(trainng_score)\n testing_avgScore = 1.0 * sum(testing_score)/len(testing_score)\n\n # find the best score\n if testing_avgScore > BestScore:\n BestScore = testing_avgScore\n best_depth = max_depth\n resultList += [[best_depth, trainng_avgScore, testing_avgScore]]\n print ('The best average score and the corresponding max_depth is: ')\n return BestScore, best_depth","def get_candidate_objects(output, img_size, classes, anchors, threshold):\n\n #threshold = 0.8\n iou_threshold = 0.4\n\n boxes, probs = parse_yolo_output_v2(output, img_size, len(classes), anchors)\n filter_mat_probs = (probs >= threshold)\n filter_mat_boxes = np.nonzero(filter_mat_probs)[0:3]\n boxes_filtered = boxes[filter_mat_boxes]\n probs_filtered = probs[filter_mat_probs]\n classes_num_filtered = np.argmax(probs, axis=3)[filter_mat_boxes]\n\n idx = np.argsort(probs_filtered)[::-1]\n boxes_filtered = boxes_filtered[idx]\n probs_filtered = probs_filtered[idx]\n classes_num_filtered = classes_num_filtered[idx]\n\n # too many detections - exit\n if len(boxes_filtered) > 1e3:\n print(\"Too many detections, maybe an error? : {}\".format(\n len(boxes_filtered)))\n return []\n\n probs_filtered = non_maxima_suppression(boxes_filtered, probs_filtered,\n classes_num_filtered, iou_threshold)\n\n filter_iou = (probs_filtered > 0.0)\n boxes_filtered = boxes_filtered[filter_iou]\n probs_filtered = probs_filtered[filter_iou]\n classes_num_filtered = classes_num_filtered[filter_iou]\n\n result = []\n for class_id, box, prob in zip(classes_num_filtered, boxes_filtered, probs_filtered):\n result.append([classes[class_id], box[0], box[1], box[2], box[3], prob])\n\n return result","def test_071_various_boosted_goal_difference_for_home_models(self):\n\n def create_model_fn(fn_team: str):\n team_stat = Stats.n_sample_stats_for_team(cursor=db_in_cursor,\n team=fn_team,\n last_sample_date=self.model_date,\n n_samples=self.num_samples,\n normalize_by_matches=True)\n\n\n return FeatureModel(\n input_data=[self.home_boost + team_stat.goal_diff, team_stat.goal_diff],\n id=team_stat.team_name\n )\n\n # TODO: convert this to use crange\n for i in range(0, 201):\n boost = i/100\n\n for match_date in played_home_OR_away_before_dates:\n ####\n # Build model up to the day before the match\n ####\n self.home_boost = boost\n self.model_date = match_date - timedelta(days=1)\n self.num_samples = num_matches_in_season\n\n models: {str: FeatureModel} = FeatureModel.create_models_for_all_teams(\n model_making_fn=create_model_fn, entities=teams)\n\n model_desc = 'gdn_boost_%s' % boost\n self.persist_models(model_gen_date=self.model_date, model_description=model_desc, models=models)\n\n self.make_and_store_predictions_for_date(match_date=match_date, models=models, variants=model_desc)","def _evaluate_performance__static_winners(self):\n # | - _evaluate_performance__\n\n # | - class attributes #################################################\n AL = self\n al_gen = self.al_gen\n verbose = self.verbose\n seed_ids = self.seed_ids\n acquisition_bin = self.acquisition_bin\n completed_ids = self.completed_ids\n CandidateSpace = self.CandidateSpace\n RegressionModel = self.RegressionModel\n DuplicateFinder = self.DuplicateFinder\n al_gen_dict = self.al_gen_dict\n\n stop_mode = self.stop_mode\n stop_num_generations = self.stop_num_generations\n\n index_acq_gen_dict = self.index_acq_gen_dict\n #__| #################################################################\n\n # #####################################################################\n mode = \"lowest_N\" # 'lowest_N' or 'lowest_perc'\n\n N_ids = 10\n lowest_perc = 5\n\n # Number of consecutive generations that the Nth best systems must\n # remain static\n M_gens = 3\n # #####################################################################\n\n if mode == \"lowest_perc\":\n num_candidates = CandidateSpace.FingerPrints.df_pre.shape[0]\n N_ids = int(num_candidates * (lowest_perc * 0.01))\n\n gen_keys = list(AL.al_gen_dict.keys())\n\n if len(gen_keys) > M_gens:\n latest_M_keys = gen_keys[-(M_gens + 1):]\n last_gen_key = gen_keys[-1]\n\n al_gen_dict_subset_i = dict(zip(\n latest_M_keys,\n [AL.al_gen_dict.get(i, None) for i in latest_M_keys]))\n\n indices_list = []\n iterator = enumerate(al_gen_dict_subset_i.items())\n for i_cnt, (gen_i, AL_i) in iterator:\n model_i = AL_i.model\n\n model_i = AL.add_main_Y_to_model(\n model_i, plot_dft_instead_of_pred=True)\n model_i = model_i[(model_i[\"duplicate\"] == False)]\n model_i = model_i.sort_values(\"Y_main\")\n\n indices_i = model_i.index.tolist()\n\n indices_list.append(indices_i)\n\n if i_cnt >= M_gens:\n indices_i = indices_list[i_cnt][0:N_ids]\n ids_static_list = []\n for j in range(M_gens):\n indices_j = indices_list[i_cnt - (j + 1)][0:N_ids]\n ids_static = indices_j == indices_i\n ids_static_list.append(ids_static)\n\n ids_are_static = all(ids_static_list)\n\n self.performance__static_winners[last_gen_key] = ids_are_static\n #__|","def majority_vote():\n iris = datasets.load_iris()\n x_vals, y_vals = iris.data[50:, [1, 2]], iris.target[50:]\n labenc = LabelEncoder()\n y_vals = labenc.fit_transform(y_vals)\n x_train, x_test, y_train, y_test = train_test_split(x_vals, y_vals,\n test_size=0.5, random_state=1)\n\n clf1 = LogisticRegression(penalty='l2', C=0.001, random_state=0)\n clf2 = DecisionTreeClassifier(max_depth=1, criterion='entropy', random_state=0)\n clf3 = KNeighborsClassifier(n_neighbors=1, p=2, metric='minkowski')\n pipe1 = Pipeline([['sc', StandardScaler()], ['clf', clf1]])\n pipe3 = Pipeline([['sc', StandardScaler()], ['clf', clf3]])\n clf_labels = ['Logistic Regression', 'Decision Tree', 'KNN']\n\n # Majority Rule (hard) Voting\n mv_clf = MajorityVoteClassifier(classifiers=[pipe1, clf2, pipe3])\n\n clf_labels += ['Majority Voting']\n all_clf = [pipe1, clf2, pipe3, mv_clf]\n print('10-fold cross validation:\\n')\n for clf, label in zip(all_clf, clf_labels):\n scores = cross_val_score(estimator=clf, X=x_train, y=y_train, cv=10, scoring='roc_auc')\n print(\"ROC AUC: %0.2f (+/- %0.2f) [%s]\" % (scores.mean(), scores.std(), label))\n\n colors = ['black', 'orange', 'blue', 'green']\n linestyles = [':', '--', '-.', '-']\n for clf, label, clr, lin_style in zip(all_clf, clf_labels, colors, linestyles):\n # assuming the label of the positive class is 1\n y_pred = clf.fit(x_train, y_train).predict_proba(x_test)[:, 1]\n fpr, tpr, _ = roc_curve(y_true=y_test, y_score=y_pred)\n print(y_pred)\n roc_auc = auc(x=fpr, y=tpr)\n plt.plot(fpr, tpr, color=clr, linestyle=lin_style,\n label='%s (auc = %0.2f)' % (label, roc_auc))\n\n plt.legend(loc='lower right')\n plt.plot([0, 1], [0, 1], linestyle='--', color='gray', linewidth=2)\n\n plt.xlim([-0.1, 1.1])\n plt.ylim([-0.1, 1.1])\n plt.grid()\n plt.xlabel('False Positive Rate')\n plt.ylabel('True Positive Rate')\n plt.tight_layout()\n plt.savefig(IMG_PATH + 'roc.png', dpi=300)\n plt.close()\n\n stdc = StandardScaler()\n x_train_std = stdc.fit_transform(x_train)\n all_clf = [pipe1, clf2, pipe3, mv_clf]\n x_min = x_train_std[:, 0].min() - 1\n x_max = x_train_std[:, 0].max() + 1\n y_min = x_train_std[:, 1].min() - 1\n y_max = x_train_std[:, 1].max() + 1\n xxx, yyy = np.meshgrid(np.arange(x_min, x_max, 0.1), np.arange(y_min, y_max, 0.1))\n _, axarr = plt.subplots(nrows=2, ncols=2, sharex='col', sharey='row', figsize=(7, 5))\n for idx, clf, ttt in zip(product([0, 1], [0, 1]), all_clf, clf_labels):\n clf.fit(x_train_std, y_train)\n z_vals = clf.predict(np.c_[xxx.ravel(), yyy.ravel()])\n z_vals = z_vals.reshape(xxx.shape)\n axarr[idx[0], idx[1]].contourf(xxx, yyy, z_vals, alpha=0.3)\n axarr[idx[0], idx[1]].scatter(x_train_std[y_train == 0, 0], x_train_std[y_train == 0, 1],\n c='blue', marker='^', s=50)\n axarr[idx[0], idx[1]].scatter(x_train_std[y_train == 1, 0], x_train_std[y_train == 1, 1],\n c='red', marker='o', s=50)\n axarr[idx[0], idx[1]].set_title(ttt)\n plt.text(-3.5, -4.5, s='Sepal width [standardized]', ha='center', va='center', fontsize=12)\n plt.text(-10.5, 4.5, s='Petal length [standardized]', ha='center', va='center',\n fontsize=12, rotation=90)\n plt.tight_layout()\n plt.savefig(IMG_PATH + 'voting_panel.png', bbox_inches='tight', dpi=300)\n # print(mv_clf.get_params())\n params = {'decisiontreeclassifier__max_depth': [1, 2],\n 'pipeline-1__clf__C': [0.001, 0.1, 100.0]}\n grid = GridSearchCV(estimator=mv_clf, param_grid=params, cv=10, scoring='roc_auc')\n grid.fit(x_train, y_train)\n\n for params, mean_score, scores in grid.cv_results_:\n print(\"%0.3f+/-%0.2f %r\" % (mean_score, scores.std() / 2, params))\n print('Best parameters: %s' % grid.best_params_)\n print('Accuracy: %.2f' % grid.best_score_)"],"string":"[\n \"def modelAdaBoost():\\n num_estimators = [1,5,10,50,100,150]\\n learning_rate = 0.1\\n max_depth = 3\\n base_estimate = DecisionTreeClassifier(max_depth=max_depth)\\n random_state = 20 # Do not change this random_state\\n \\n obj_boost = []\\n \\n \\\"\\\"\\\" \\n Create a list of objects for the classifier \\n for each of combination of above num_estimators and learning_rate\\n \\\"\\\"\\\"\\n for n_est in num_estimators:\\n boost = AdaBoostClassifier(n_estimators=n_est, \\n learning_rate=learning_rate, \\n base_estimator = base_estimate, \\n random_state =random_state)\\n obj_boost.append(boost)\\n\\n return obj_boost\",\n \"def give_balanced_classes(reviews, votes, votes_threshold):\\n if votes_threshold <= 0:\\n print \\\"Needs positive threshold\\\"\\n return\\n\\n negative_reviews_indices = []\\n\\n # Find all the funny reviews we can\\n final_reviews = []\\n final_labels = []\\n for i, review in enumerate(reviews):\\n if votes[i] >= votes_threshold:\\n final_reviews.append(review)\\n final_labels.append(1)\\n elif votes[i] == 0:\\n negative_reviews_indices.append(i)\\n\\n # We want balanced classes so take same number\\n np.random.shuffle(negative_reviews_indices)\\n num_positive_reviews = len(final_reviews)\\n for i in range(num_positive_reviews):\\n final_reviews.append(reviews[negative_reviews_indices[i]])\\n final_labels.append(0)\\n\\n # Shuffle final reviews and labels\\n combined_lists = zip(final_reviews, final_labels)\\n np.random.shuffle(combined_lists)\\n final_reviews[:], final_labels[:] = zip(*combined_lists)\\n\\n print \\\"Returning %d positive reviews and a total of %d reviews\\\" % (num_positive_reviews, len(final_reviews))\\n\\n return (final_reviews, final_labels)\",\n \"def predict_boosting_example(x, h_ens):\\r\\n\\r\\n arr = []\\r\\n sum_alpha = 0\\r\\n\\r\\n for y in h_ens:\\r\\n # splitting hypothesis, weight pairs\\r\\n alpha, tree = h_ens[y]\\r\\n tst_pred = predict_example(x, tree)\\r\\n # appending prediction\\r\\n arr.append(tst_pred*alpha)\\r\\n sum_alpha += alpha\\r\\n predict_egz = np.sum(arr) / sum_alpha\\r\\n # weak learner\\r\\n if predict_egz >= 0.5:\\r\\n return 1\\r\\n else:\\r\\n return 0\",\n \"def predict_bagging_example(x, h_ens):\\r\\n arr = []\\r\\n for y in h_ens:\\r\\n \\t# calls predict example repeatedly and stores them in an array\\r\\n tst_pred = predict_example(x, h_ens[y][1])\\r\\n arr.append(tst_pred)\\r\\n # returning the maximum voted\\r\\n predict_egz = max(set(arr), key=arr.count)\\r\\n return predict_egz\",\n \"def from_adaboost(cls, X_train, y_train, data_normalizer_class, n_classifiers):\\n\\n normalizer = data_normalizer_class().fit(X_train.values)\\n X_train = pd.DataFrame(data=normalizer.transform(X_train.values), index=X_train.index, columns=X_train.columns)\\n\\n rf = AdaBoostClassifier(n_estimators=n_classifiers, algorithm='SAMME') # type: AdaBoostClassifier\\n rf = rf.fit(X_train, y_train) # type: AdaBoostClassifier\\n\\n n_classes = rf.n_classes_\\n\\n voting_weights = np.empty((n_classifiers, n_classes), dtype=np.float32)\\n voting_weights[:] = rf.estimator_weights_[:, np.newaxis]\\n\\n ensemble = Ensemble(\\n X_train=X_train, y_train=y_train,\\n data_normalizer_class=normalizer,\\n classifiers=rf.estimators_,\\n features=np.ones(\\n (n_classifiers, X_train.shape[1]), dtype=np.int32\\n ),\\n activated=np.ones(n_classifiers, dtype=np.int32),\\n voting_weights=voting_weights,\\n )\\n return ensemble\",\n \"def adaBoost(trainingSamples, weights, featuresSet, classifierCount, threadCount=12, verbose=True):\\n #result\\n classifiers = []\\n classifierWeights = []\\n \\n for i in range(0, classifierCount):\\n if verbose:\\n print(\\\"Training classifier \\\" + str(i+1) + \\\"/\\\" + str(classifierCount) + \\\"....\\\")\\n\\n #normalize weights\\n weights = normWeights(weights)\\n \\n ########## train all classifiers ##########\\n #build workers\\n workers = []\\n for chunk in chunks(featuresSet, threadCount):\\n workers.append(Trainer(trainingSamples, weights, chunk))\\n\\n #run them in a thread pool\\n trainedClassifiers = []\\n with Pool(processes=threadCount) as pool:\\n trainedClassifiers = pool.map(workerRunner, workers)\\n trainedClassifiers = getResults(trainedClassifiers)\\n\\n ########## compute error for each classifier ##########\\n #build workers\\n workers = []\\n for chunk in chunks(trainedClassifiers, threadCount):\\n workers.append(ErrorWorker(trainingSamples, weights, chunk))\\n \\n #run them in a thread pool\\n errors = []\\n with Pool(processes=threadCount) as pool:\\n errors = pool.map(workerRunner, workers)\\n errors = getResults(errors)\\n\\n #choose the classifier with the lowest error\\n errors = np.array(errors) \\n bestError = errors.min()\\n bestClassifierIndex = np.where(errors == errors.min())[0][0]\\n bestClassifier = trainedClassifiers[bestClassifierIndex]\\n b = bestError/(1-bestError)\\n classifiers.append(bestClassifier)\\n if verbose:\\n print(\\\"Found feature with error: \\\" + str(bestError))\\n \\n #remove used feature from the dataset\\n del featuresSet[bestClassifierIndex]\\n \\n #compute classifier weight\\n classifierWeight = np.log(1/b)\\n classifierWeights.append(classifierWeight)\\n if verbose:\\n print(\\\"Classifier has weight: \\\" + str(classifierWeight))\\n \\n #update weights\\n for i in range(0, len(weights)):\\n weights[i] = weights[i]*np.power(b, 1-bestError)\\n\\n return classifiers, classifierWeights\",\n \"def evaluation(self):\\n rows_list = []\\n for name in self.single_classifier_best.keys():\\n row = {}\\n row['algorithm'] = name \\n row[self.scoring_metric] = self.single_classifier_best[name].best_score_\\n rows_list.append(row)\\n \\n scoring_df = pd.DataFrame(rows_list)\\n scoring_sorted = scoring_df.sort_values(self.scoring_metric, ascending=False)\\n print()\\n print('*'*shutil.get_terminal_size().columns)\\n print(scoring_sorted)\\n print('*'*shutil.get_terminal_size().columns)\\n self.evaluation_scores = scoring_sorted\",\n \"def lazy_greedy_max(self, budget):\\r\\n\\r\\n classes, no_elements = torch.unique(self.y_trn, return_counts=True)\\r\\n len_unique_elements = no_elements.shape[0]\\r\\n per_class_bud = int(budget / len(classes))\\r\\n final_per_class_bud = []\\r\\n _, sorted_indices = torch.sort(no_elements, descending = True)\\r\\n\\r\\n if self.selection_type == 'PerClass':\\r\\n \\r\\n total_idxs = 0\\r\\n for n_element in no_elements:\\r\\n final_per_class_bud.append(min(per_class_bud, torch.IntTensor.item(n_element)))\\r\\n total_idxs += min(per_class_bud, torch.IntTensor.item(n_element))\\r\\n \\r\\n if total_idxs < budget:\\r\\n bud_difference = budget - total_idxs\\r\\n for i in range(len_unique_elements):\\r\\n available_idxs = torch.IntTensor.item(no_elements[sorted_indices[i]])-per_class_bud \\r\\n final_per_class_bud[sorted_indices[i]] += min(bud_difference, available_idxs)\\r\\n total_idxs += min(bud_difference, available_idxs)\\r\\n bud_difference = budget - total_idxs\\r\\n if bud_difference == 0:\\r\\n break\\r\\n\\r\\n total_greedy_list = []\\r\\n for i in range(len_unique_elements):\\r\\n idxs = torch.where(self.y_trn == classes[i])[0]\\r\\n \\r\\n if self.submod == 'facility_location':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.facilityLocation.FacilityLocationSelection(random_state=0, metric='precomputed',\\r\\n n_samples=final_per_class_bud[i])\\r\\n elif self.submod == 'graph_cut':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.graphCut.GraphCutSelection(random_state=0, metric='precomputed',\\r\\n n_samples=final_per_class_bud[i])\\r\\n elif self.submod == 'saturated_coverage':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.saturatedCoverage.SaturatedCoverageSelection(random_state=0, metric='precomputed',\\r\\n n_samples=final_per_class_bud[i])\\r\\n elif self.submod == 'sum_redundancy':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.sumRedundancy.SumRedundancySelection(random_state=0, metric='precomputed',\\r\\n n_samples=final_per_class_bud[i])\\r\\n elif self.submod == 'feature_based':\\r\\n fl = apricot.functions.featureBased.FeatureBasedSelection(random_state=0, n_samples=final_per_class_bud[i])\\r\\n\\r\\n if self.submod == 'feature_based':\\r\\n\\r\\n x_sub = fl.fit_transform(self.x_trn[idxs].numpy())\\r\\n greedyList = self.get_index(self.x_trn[idxs].numpy(), x_sub)\\r\\n total_greedy_list.extend(idxs[greedyList])\\r\\n\\r\\n else: \\r\\n\\r\\n sim_sub = fl.fit_transform(self.dist_mat.cpu().numpy())\\r\\n greedyList = list(np.argmax(sim_sub, axis=1))\\r\\n total_greedy_list.extend(idxs[greedyList])\\r\\n\\r\\n elif self.selection_type == 'Supervised':\\r\\n \\r\\n \\r\\n if self.submod == 'feature_based':\\r\\n \\r\\n class_map = {}\\r\\n for i in range(len_unique_elements):\\r\\n class_map[torch.IntTensor.item(classes[i])] = i #Mapping classes from 0 to n\\r\\n \\r\\n sparse_data = torch.zeros([self.x_trn.shape[0], self.x_trn.shape[1]*len_unique_elements])\\r\\n for i in range(self.x_trn.shape[0]):\\r\\n \\r\\n start_col = class_map[torch.IntTensor.item(self.y_trn[i])]*self.x_trn.shape[1]\\r\\n end_col = start_col+self.x_trn.shape[1]\\r\\n sparse_data[i, start_col:end_col] = self.x_trn[i, :]\\r\\n\\r\\n fl = apricot.functions.featureBased.FeatureBasedSelection(random_state=0, n_samples=budget)\\r\\n x_sub = fl.fit_transform(sparse_data.numpy())\\r\\n total_greedy_list = self.get_index(sparse_data.numpy(), x_sub)\\r\\n\\r\\n else:\\r\\n for i in range(len(classes)):\\r\\n \\r\\n if i == 0:\\r\\n idxs = torch.where(self.y_trn == classes[i])[0]\\r\\n N = len(idxs)\\r\\n self.compute_score(idxs)\\r\\n row = idxs.repeat_interleave(N)\\r\\n col = idxs.repeat(N)\\r\\n data = self.dist_mat.cpu().numpy().flatten()\\r\\n else:\\r\\n idxs = torch.where(self.y_trn == classes[i])[0]\\r\\n N = len(idxs)\\r\\n self.compute_score(idxs)\\r\\n row = torch.cat((row, idxs.repeat_interleave(N)), dim=0)\\r\\n col = torch.cat((col, idxs.repeat(N)), dim=0)\\r\\n data = np.concatenate([data, self.dist_mat.cpu().numpy().flatten()], axis=0)\\r\\n \\r\\n \\r\\n sparse_simmat = csr_matrix((data, (row.numpy(), col.numpy())), shape=(self.N_trn, self.N_trn))\\r\\n #self.dist_mat = sparse_simmat\\r\\n\\r\\n if self.submod == 'facility_location':\\r\\n fl = apricot.functions.facilityLocation.FacilityLocationSelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'graph_cut':\\r\\n fl = apricot.functions.graphCut.GraphCutSelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'saturated_coverage':\\r\\n fl = apricot.functions.saturatedCoverage.SaturatedCoverageSelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'sum_redundancy':\\r\\n fl = apricot.functions.sumRedundancy.SumRedundancySelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n sim_sub = fl.fit_transform(sparse_simmat)\\r\\n total_greedy_list = list(np.array(np.argmax(sim_sub, axis=1)).reshape(-1))\\r\\n\\r\\n\\r\\n if self.selection_type == 'Full':\\r\\n \\r\\n\\r\\n total_greedy_list = []\\r\\n idx_end = self.x_trn.shape[0] - 1\\r\\n idxs = torch.linspace(0, idx_end, self.x_trn.shape[0]).long()\\r\\n\\r\\n if self.submod == 'facility_location':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.facilityLocation.FacilityLocationSelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'graph_cut':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.graphCut.GraphCutSelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'saturated_coverage':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.saturatedCoverage.SaturatedCoverageSelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'sum_redundancy':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.sumRedundancy.SumRedundancySelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'feature_based':\\r\\n fl = apricot.functions.featureBased.FeatureBasedSelection(random_state=0, n_samples=budget)\\r\\n\\r\\n if self.submod == 'feature_based':\\r\\n\\r\\n x_sub = fl.fit_transform(self.x_trn.numpy())\\r\\n total_greedy_list = self.get_index(self.x_trn.numpy(), x_sub)\\r\\n\\r\\n else: \\r\\n\\r\\n sim_sub = fl.fit_transform(self.dist_mat.cpu().numpy())\\r\\n total_greedy_list = list(np.argmax(sim_sub, axis=1))\\r\\n\\r\\n return total_greedy_list\",\n \"def collect_best_features(self):\\n bincsp = self.binary_csp # just to make code shorter\\n n_folds = len(self.binary_csp.folds)\\n n_class_pairs = len(self.binary_csp.class_pairs)\\n result_shape = (n_folds, n_class_pairs)\\n self.train_feature = np.empty(result_shape, dtype=object)\\n self.train_feature_full_fold = np.empty(result_shape, dtype=object)\\n self.test_feature = np.empty(result_shape, dtype=object)\\n self.test_feature_full_fold = np.empty(result_shape, dtype=object)\\n self.selected_filters_per_filterband = np.empty(result_shape, dtype=object)\\n for fold_i in range(n_folds):\\n for class_pair_i in range(n_class_pairs):\\n bin_csp_train_features = deepcopy(bincsp.train_feature[\\n self.selected_filter_inds, fold_i, class_pair_i])\\n bin_csp_train_features_full_fold = deepcopy(\\n bincsp.train_feature_full_fold[\\n self.selected_filter_inds,\\n fold_i, class_pair_i])\\n bin_csp_test_features = deepcopy(bincsp.test_feature[\\n self.selected_filter_inds, fold_i, class_pair_i])\\n bin_csp_test_features_full_fold = deepcopy(\\n bincsp.test_feature_full_fold[\\n self.selected_filter_inds,fold_i, class_pair_i])\\n selected_filters_per_filt = self.select_best_filters_best_filterbands(\\n bin_csp_train_features, max_features=self.n_features,\\n forward_steps=self.forward_steps, \\n backward_steps=self.backward_steps,\\n stop_when_no_improvement=self.stop_when_no_improvement)\\n self.train_feature[fold_i, class_pair_i] = \\\\\\n self.collect_features_for_filter_selection(\\n bin_csp_train_features, selected_filters_per_filt)\\n self.train_feature_full_fold[fold_i, class_pair_i] = \\\\\\n self.collect_features_for_filter_selection(\\n bin_csp_train_features_full_fold, selected_filters_per_filt)\\n \\n self.test_feature[fold_i, class_pair_i] = \\\\\\n self.collect_features_for_filter_selection(\\n bin_csp_test_features, selected_filters_per_filt)\\n self.test_feature_full_fold[fold_i, class_pair_i] = \\\\\\n self.collect_features_for_filter_selection(\\n bin_csp_test_features_full_fold, selected_filters_per_filt)\\n \\n self.selected_filters_per_filterband[fold_i, class_pair_i] = \\\\\\n selected_filters_per_filt\",\n \"def get_optimal_rounds(dtrain, param):\\n num_round = 1000\\n bst = xgb.cv(param, dtrain, num_round, nfold=10,\\n metrics={'logloss', 'auc'}, seed=0,\\n callbacks=[xgb.callback.print_evaluation(show_stdv=True),\\n xgb.callback.early_stop(10)])\\n return len(bst)-1\",\n \"def ensemble_accuracy(n_classifiers, accuracy):\\n k_start = int(math.ceil(n_classifiers / 2.0))\\n probs = [comb(n_classifiers, k) *\\n accuracy**k *\\n (1 - accuracy)**(n_classifiers - k)\\n for k in range(k_start, n_classifiers + 1)]\\n return sum(probs)\",\n \"def try_ada_boost_decision_tree():\\n\\n print(\\\"AdaBoost to Decision Tree\\\")\\n from sklearn.tree import DecisionTreeClassifier\\n from sklearn.ensemble import AdaBoostClassifier\\n from sklearn.grid_search import GridSearchCV\\n\\n param_grid = {\\\"base_estimator__criterion\\\" : [\\\"gini\\\", \\\"entropy\\\"],\\n \\\"base_estimator__splitter\\\" : [\\\"best\\\", \\\"random\\\"],\\n \\\"n_estimators\\\": [10, 30]\\n }\\n\\n DTC = DecisionTreeClassifier(random_state = 11, max_features = \\\"auto\\\", class_weight = \\\"balanced\\\",max_depth = None)\\n\\n ABC = AdaBoostClassifier(base_estimator = DTC)\\n\\n grid_search_ABC = GridSearchCV(ABC, param_grid=param_grid, scoring = 'roc_auc')\\n\\n grid_search_ABC.fit(features_train,labels_train)\\n\\n pred = grid_search_ABC.predict(features_test)\\n accuracy = accuracy_score(labels_test, pred)\\n precision = precision_score(labels_test, pred)\\n recall = recall_score(labels_test, pred)\\n\\n print(\\\"DecisionTree after applying AdaBoost and GridSearchCV:\\\")\\n print(\\\"accuracy AdaBoost: \\\", accuracy)\\n print(\\\"precision: \\\", precision)\\n print(\\\"recall: \\\", recall)\\n print_separator_line()\\n dict_results = { \\\"classifier\\\": \\\"AdaBoost decision tree\\\", \\\"accuracy\\\": accuracy, \\\"precision\\\": precision, \\\"recall\\\": recall }\\n return dict_results, grid_search_ABC\",\n \"def classify(self, data):\\n guesses = []\\n for datum in data:\\n vectors = util.Counter()\\n for l in self.legalLabels:\\n vectors[l] = self.weights[l] * datum + self.bias[l]\\n guesses.append(vectors.argMax())\\n return guesses\",\n \"def ensembleVote(x, classes, ensemble):\\n votes = np.array([0 for kk in range(len(classes))])\\n for i in ensemble:\\n votes = votes + classProbs(x, ensemble[i][\\\"tree\\\"], classes)\\n maxVote = 0\\n loc = None\\n for ind, vote in enumerate(votes):\\n if vote > maxVote:\\n maxVote = vote\\n loc = ind\\n prediction = classes[loc]\\n return prediction\",\n \"def classify(self, data ):\\n guesses = []\\n for datum in data:\\n vectors = util.Counter()\\n for l in self.legalLabels:\\n vectors[l] = self.weights[l] * datum\\n guesses.append(vectors.argMax())\\n return guesses\",\n \"def main(keep_best_count, mutation_factor, rounds, target, stagnate):\\n ways = [range(len(DISTANCES))]\\n result = {'round':0,'cost':None}\\n for i in range(rounds):\\n ways = mutate(ways,mutation_factor)\\n best = []\\n for way in ways:\\n best.append((rate(way),way))\\n best.sort()\\n if VERBOSITY:\\n for way in best:\\n print way\\n print \\\"Round %d best way is %s\\\" % (i+1, best[0][0])\\n # break if we hit the target\\n if best[0][0] <= target:\\n print \\\"Hit Target\\\"\\n break\\n # break if we stagnate to long\\n if result['cost'] is None or best[0][0] <result['cost']:\\n result['cost'] = best[0][0]\\n result['round'] = i+1\\n elif result['round'] + stagnate <= i+1:\\n print \\\"Stagnate to long\\\"\\n break\\n ways = list(b[1] for b in best[0:keep_best_count])\\n print \\\"\\\"\\n print \\\"best found order with cost=%d\\\" % best[0][0]\\n print ' '.join(list(NAMES[i] for i in best[0][1]))\\n print \\\"\\\"\",\n \"def __call__(self, clfs, dataset):\\n if len(clfs)==0:\\n return [] # to don't even bother\\n\\n all_label_counts = None\\n for clf in clfs:\\n # Lets check first if necessary conditional attribute is enabled\\n if not clf.ca.is_enabled(\\\"predictions\\\"):\\n raise ValueError, \\\"MaximalVote needs classifiers (such as \\\" + \\\\\\n \\\"%s) with state 'predictions' enabled\\\" % clf\\n predictions = clf.ca.predictions\\n if all_label_counts is None:\\n all_label_counts = [ {} for i in xrange(len(predictions)) ]\\n\\n # for every sample\\n for i in xrange(len(predictions)):\\n prediction = predictions[i]\\n # XXX fishy location due to literal labels,\\n # TODO simplify assumptions and logic\\n if isinstance(prediction, basestring) or \\\\\\n not is_sequence_type(prediction):\\n prediction = (prediction,)\\n for label in prediction: # for every label\\n # XXX we might have multiple labels assigned\\n # but might not -- don't remember now\\n if not label in all_label_counts[i]:\\n all_label_counts[i][label] = 0\\n all_label_counts[i][label] += 1\\n\\n predictions = []\\n # select maximal vote now for each sample\\n for i in xrange(len(all_label_counts)):\\n label_counts = all_label_counts[i]\\n # lets do explicit search for max so we know\\n # if it is unique\\n maxk = [] # labels of elements with max vote\\n maxv = -1\\n for k, v in label_counts.iteritems():\\n if v > maxv:\\n maxk = [k]\\n maxv = v\\n elif v == maxv:\\n maxk.append(k)\\n\\n assert len(maxk) >= 1, \\\\\\n \\\"We should have obtained at least a single key of max label\\\"\\n\\n if len(maxk) > 1:\\n warning(\\\"We got multiple labels %s which have the \\\" % maxk +\\n \\\"same maximal vote %d. XXX disambiguate. \\\" % maxv +\\n \\\"Meanwhile selecting the first in sorted order\\\")\\n predictions.append(sorted(maxk)[0])\\n\\n ca = self.ca\\n ca.estimates = all_label_counts\\n ca.predictions = predictions\\n return predictions\",\n \"def classify(X, Y, skf, clf, round_threshold=0.5, average=\\\"macro\\\"):\\n X = X.values\\n if isinstance(Y, pd.Series):\\n labels = [\\\"{}_0\\\".format(Y.name), \\\"{}_1\\\".format(Y.name)]\\n Y = np.ravel(Y)\\n else:\\n Y, labels = Y.values, list(Y.columns)\\n\\n fold_results = []\\n for train, test in skf.split(X, Y):\\n current_clf = clone(clf)\\n X_train, X_test, Y_train, Y_test = X[train], X[test], Y[train], Y[test]\\n\\n current_clf.fit(X_train, Y_train)\\n Y_prob = current_clf.predict_proba(X_test)\\n Y_pred = current_clf.predict(X_test)\\n\\n (p, r, f1, auc, jac, hl, p_c,\\n r_c, f1_c, s_c) = calculate_metrics(Y_test, Y_pred, Y_prob, average)\\n\\n # calculate overall scores for current fold\\n fold_scores = {\\n \\\"precision\\\": p,\\n \\\"recall\\\": r,\\n \\\"f1\\\": f1,\\n \\\"auc\\\": auc,\\n \\\"jaccard\\\": jac,\\n \\\"hamming_loss\\\": hl\\n }\\n\\n for i in range(len(labels)):\\n fold_scores[\\\"precision_{0}\\\".format(labels[i])] = p_c[i]\\n fold_scores[\\\"recall_{0}\\\".format(labels[i])] = r_c[i]\\n fold_scores[\\\"f1_{0}\\\".format(labels[i])] = f1_c[i]\\n fold_scores[\\\"support_{0}\\\".format(labels[i])] = s_c[i]\\n\\n fold_results.append({\\n \\\"scores\\\": fold_scores,\\n \\\"y_pred\\\": Y_pred,\\n \\\"y_prob\\\": Y_prob,\\n \\\"y_test\\\": Y_test\\n })\\n\\n scores = {}\\n for score in fold_results[0][\\\"scores\\\"].keys():\\n values = [s[\\\"scores\\\"][score] for s in fold_results]\\n scores[score] = (np.sum(values) if score.startswith(\\\"support_\\\")\\n else np.mean(values))\\n\\n return scores, fold_results\",\n \"def classify(self, data):\\n guesses = []\\n for datum in data:\\n vectors = util.Counter()\\n for l in self.legalLabels:\\n vectors[l] = self.weights[l] * datum\\n guesses.append(vectors.argMax())\\n return guesses\",\n \"def classify(self, testData):\\n\\tguesses = []\\n\\tself.posteriors = [] # Log posteriors are stored for later data analysis (autograder).\\n\\tfor datum in testData:\\n\\t posterior = self.calculateLogJointProbabilities(datum)\\n\\t guesses.append(posterior.argMax())\\n\\t self.posteriors.append(posterior)\\n\\treturn guesses\",\n \"def fit(self, X, y):\\n X_array=np.asarray(X) \\n X_data_int=X_array[:,0:X_array.shape[1]-1]\\n X_data= X_data_int/1.0\\n \\n p=1\\n number_of_p=int(X_data.shape[0]*p)\\n l = range(0,X_data.shape[0])\\n randlist = random.sample(l, number_of_p) \\n \\n for i in randlist:\\n y[i]=y[i]*(-1)\\n\\n sample_weight2 = np.empty(X_data.shape[0], dtype=np.float)\\n sample_weight2[:] = 1. / X_data.shape[0]\\n self.estimators_ = []\\n\\n\\n self.estimator_errors_ = np.ones(self.iters, dtype=np.float)\\n \\n #classfier=CLASSIFIERS[self.algorithm]()\\n \\n for iboost in range(self.iters):\\n # Boosting step\\n classfier=CLASSIFIERS[self.algorithm]() \\n sample_weight3=[]\\n sample_weight3=sample_weight2\\n classfier.fit(X_data, y,sample_weight3)\\n y_predict = classfier.predict(X_data)\\n \\n # Instances incorrectly classified\\n incorrect = y_predict != y\\n\\n # Error fraction\\n \\n estimator_error = np.mean(np.average(incorrect, weights=sample_weight2, axis=0))\\n #estimator_error = np.sum(np.average(incorrect, weights=sample_weight2, axis=0))\\n \\n # Stop if classification is perfect\\n if estimator_error <= 0:\\n estimator_weight = 1.\\n estimator_error = 0.\\n \\n # Stop if the error is at least as bad as random guessing\\n if estimator_error >= 1. - (1. / 2):\\n raise ValueError('BaseClassifier in AdaBoostClassifier '\\n 'ensemble is worse than random, ensemble '\\n 'can not be fit.')\\n break\\n\\n #estimator_weight = 1./2*np.log((1. - estimator_error) / estimator_error)\\n estimator_weight = np.log((1. - estimator_error) / estimator_error)\\n # Only boost the weights if I will fit again\\n if not iboost == self.iters - 1:\\n # Only boost positive weights\\n sample_weight2 *= np.exp(estimator_weight * incorrect * ((sample_weight2 > 0) | (estimator_weight < 0)))\\n\\n # Early termination\\n if sample_weight2 is None:\\n break\\n\\n self.estimator_weights_[iboost] = estimator_weight\\n self.estimator_errors_[iboost] = estimator_error\\n\\n # Stop if error is zero\\n if estimator_error == 0:\\n break\\n\\n sample_weight_sum = np.sum(sample_weight2)\\n \\n\\n # Stop if the sum of sample weights has become non-positive\\n if sample_weight_sum <= 0:\\n break\\n\\n if iboost < self.iters - 1:\\n # Normalize\\n sample_weight2 /= sample_weight_sum\\n \\n self.estimators_.append(classfier)\\n\\n return self\",\n \"def naive_bayes_classify(df: pd.DataFrame, vect, names):\\n features = vect\\n target = df.success_lvl\\n\\n X_train, X_test, y_train, y_test = \\\\\\n train_test_split(features, target, test_size=0.2, random_state=42)\\n\\n nb_clf = MultinomialNB()\\n nb_clf.fit(X_train, y_train)\\n nb_predictions = nb_clf.predict(X_test)\\n print('Accuracy score for Naive Bayes:', accuracy_score(y_test, nb_predictions))\\n\\n\\n # Find Top/Bottom num of terms used to describe the classes.\\n num = 10\\n low_class_prob_sorted = nb_clf.feature_log_prob_[0, :].argsort()[::-1]\\n hi_class_prob_sorted = nb_clf.feature_log_prob_[1, :].argsort()[::-1]\\n print('\\\\n', f'Low score Top{num} phrases:', np.take(names, low_class_prob_sorted[:num]))\\n print('\\\\n', f'Low score Bot{num} phrases:', np.take(names, low_class_prob_sorted[-num:]))\\n print('\\\\n', f'High score Top{num} phrases:', np.take(names, hi_class_prob_sorted[:num]))\\n print('\\\\n', f'High score Bot{num} phrases:', np.take(names, hi_class_prob_sorted[-num:]))\",\n \"def borda(election, tiebreaker=None):\\n election = np.asarray(election)\\n\\n ncands = election.shape[1]\\n total_tally = np.zeros(ncands, dtype=int)\\n\\n # Tally candidates in each column, multiply by points for each rank level\\n for n, column in enumerate(election.T):\\n tally = np.bincount(column, minlength=ncands)\\n total_tally += (ncands - n)*tally\\n\\n # Python lists are faster than NumPy here\\n total_tally = total_tally.tolist()\\n\\n # Find the set of candidates who have the highest score (usually only one)\\n highest = max(total_tally)\\n winners = _all_indices(total_tally, highest)\\n\\n # Break any ties using specified method\\n tiebreak = _get_tiebreak(tiebreaker, _tiebreak_map)\\n return tiebreak(winners)[0]\",\n \"def tune_learning_algo(data_X, data_y, params_set, algo_factory, folds=5):\\n accuracy_for_params = {}\\n best_accuracy = 0.0\\n best_params = None\\n\\n # For all the available parameters, do a k-fold evaluation to get average accuracy.\\n # Report the params with best accuracy.\\n for params in params_set:\\n # Do a k fold training and evaluation for this params and get average accuracy.\\n accuracy = train_and_evaluate_k_fold(data_X, data_y, params, algo_factory, folds)\\n # Save\\n accuracy_for_params[params] = accuracy\\n # Update the best parameters till now.\\n if accuracy > best_accuracy:\\n best_params = params\\n best_accuracy = accuracy\\n # Return.\\n return accuracy_for_params, best_params\",\n \"def classify(self, data ):\\n\\t\\tguesses = []\\n\\t\\tfor datum in data:\\n\\t\\t\\tvectors = util.Counter()\\n\\t\\t\\tfor l in self.legalLabels:\\n\\t\\t\\t\\tvectors[l] = self.weights[l] * datum\\n\\t\\t\\tguesses.append(vectors.argMax())\\n\\t\\treturn guesses\",\n \"def classify(self, data ):\\n\\t\\tguesses = []\\n\\t\\tfor datum in data:\\n\\t\\t\\tvectors = util.Counter()\\n\\t\\t\\tfor l in self.legalLabels:\\n\\t\\t\\t\\tvectors[l] = self.weights[l] * datum\\n\\t\\t\\tguesses.append(vectors.argMax())\\n\\t\\treturn guesses\",\n \"def classify(self, testData):\\n guesses = []\\n self.posteriors = [] # Log posteriors are stored for later data analysis (autograder).\\n for datum in testData:\\n posterior = self.calculateLogJointProbabilities(datum)\\n guesses.append(posterior.argMax())\\n self.posteriors.append(posterior)\\n return guesses\",\n \"def classify(self, testData):\\n guesses = []\\n self.posteriors = [] # Log posteriors are stored for later data analysis (autograder).\\n for datum in testData:\\n posterior = self.calculateLogJointProbabilities(datum)\\n guesses.append(posterior.argMax())\\n self.posteriors.append(posterior)\\n return guesses\",\n \"def get_bests(self):\\n set_names = [\\\"training\\\", \\\"hp_selection\\\", \\\"validation\\\"]\\n run_tec_conf_set = recursivedict()\\n validation = self._campaign_configuration['General']['validation']\\n hp_selection = self._campaign_configuration['General']['hp_selection']\\n if (validation, hp_selection) in {(\\\"All\\\", \\\"All\\\"), (\\\"Extrapolation\\\", \\\"All\\\"), (\\\"All\\\", \\\"HoldOut\\\"), (\\\"HoldOut\\\", \\\"All\\\"), (\\\"HoldOut\\\", \\\"HoldOut\\\"), (\\\"Extrapolation\\\", \\\"HoldOut\\\")}:\\n # For each run, for each technique the best configuration\\n run_tec_best_conf = recursivedict()\\n\\n # Hyperparameter search\\n for conf in self._exp_confs:\\n run = int(conf.get_signature()[0].replace(\\\"run_\\\", \\\"\\\"))\\n technique = conf.technique\\n run_tec_conf_set[run][technique][str(conf.get_signature()[4:])] = conf.mapes\\n # First experiment for this technique or better than the current best\\n if technique not in run_tec_best_conf[run] or conf.mapes[\\\"hp_selection\\\"] < run_tec_best_conf[run][technique].mapes[\\\"hp_selection\\\"]:\\n run_tec_best_conf[run][technique] = conf\\n\\n # Print results for each run\\n for run in range(0, self._campaign_configuration['General']['run_num']):\\n self._logger.info(\\\"-->Printing results for run %s\\\", str(run))\\n overall_run_best = None\\n # Print data of single techniques\\n for technique in run_tec_best_conf[run]:\\n temp = run_tec_best_conf[run][technique]\\n self._logger.info(\\\"---Best result for %s - Configuration is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", technique, temp.get_signature()[4:], temp.mapes[\\\"training\\\"], temp.mapes[\\\"hp_selection\\\"], temp.mapes[\\\"validation\\\"])\\n\\n # Compute which is the best technique\\n if not overall_run_best or temp.mapes[\\\"hp_selection\\\"] < overall_run_best.mapes[\\\"hp_selection\\\"]:\\n overall_run_best = temp\\n best_model_description = overall_run_best.print_model()\\n self._logger.info(\\\"<--Overall best result is %s %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", overall_run_best.get_signature()[3:], \\\"(\\\" + best_model_description + \\\")\\\" if best_model_description else \\\"\\\", overall_run_best.mapes[\\\"training\\\"], overall_run_best.mapes[\\\"hp_selection\\\"], overall_run_best.mapes[\\\"validation\\\"])\\n\\n elif (validation, hp_selection) in {(\\\"KFold\\\", \\\"All\\\"), (\\\"KFold\\\", \\\"HoldOut\\\")}:\\n folds = float(self._campaign_configuration['General']['folds'])\\n # For each run, for each fold, for each technique, the best configuration\\n run_fold_tec_best_conf = recursivedict()\\n\\n # Hyperparameter search inside each fold\\n for conf in self._exp_confs:\\n run = int(conf.get_signature()[0].replace(\\\"run_\\\", \\\"\\\"))\\n fold = int(conf.get_signature()[1].replace(\\\"f\\\", \\\"\\\"))\\n technique = conf.technique\\n if \\\"hp_selection\\\" not in run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])]:\\n for set_name in set_names:\\n run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])][set_name] = 0\\n for set_name in set_names:\\n run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])][set_name] = run_tec_conf_set[run][technique][str(conf.get_signature_string()[4:])][set_name] + conf.mapes[set_name] / folds\\n # First experiment for this fold+technique or better than the current best\\n if technique not in run_fold_tec_best_conf[run][fold] or conf.mapes[\\\"hp_selection\\\"] < run_fold_tec_best_conf[run][fold][technique].mapes[\\\"hp_selection\\\"]:\\n run_fold_tec_best_conf[run][fold][technique] = conf\\n\\n # Aggregate different folds (only the value of the mapes)\\n run_tec_set = recursivedict()\\n for run in run_fold_tec_best_conf:\\n for fold in run_fold_tec_best_conf[run]:\\n for tec in run_fold_tec_best_conf[run][fold]:\\n if \\\"hp_selection\\\" not in run_tec_set[run][technique]:\\n for set_name in set_names:\\n run_tec_set[run][tec][set_name] = 0\\n for set_name in set_names:\\n run_tec_set[run][tec][set_name] = run_fold_tec_best_conf[run][fold][tec].mapes[set_name]\\n # Print results for each run\\n for run in range(0, self._campaign_configuration['General']['run_num']):\\n self._logger.info(\\\"Printing results for run %s\\\", str(run))\\n overall_run_best = ()\\n # Print data of single techniques\\n for technique in run_tec_set[run]:\\n self._logger.info(\\\"---Best result for %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", technique, run_tec_set[run][technique][\\\"training\\\"], run_tec_set[run][technique][\\\"hp_selection\\\"], run_tec_set[run][technique][\\\"validation\\\"])\\n\\n # Compute which is the best technique\\n if not overall_run_best or run_tec_set[run][technique][\\\"hp_selection\\\"] < overall_run_best[1][\\\"hp_selection\\\"]:\\n overall_run_best = (technique, run_tec_set[run][technique])\\n\\n self._logger.info(\\\"---Overall best result is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", overall_run_best[0], overall_run_best[1][\\\"training\\\"], overall_run_best[1][\\\"hp_selection\\\"], overall_run_best[1][\\\"validation\\\"])\\n\\n # Overall best will contain as first argument the technique with the best (across runs) average (across folds) mape on validation; now we consider on all the runs and on all the folds the configuraiton of this technique with best validation mape\\n\\n elif (validation, hp_selection) in {(\\\"All\\\", \\\"KFold\\\"), (\\\"HoldOut\\\", \\\"KFold\\\"), (\\\"Extrapolation\\\", \\\"KFold\\\")}:\\n folds = float(self._campaign_configuration['General']['folds'])\\n # For each run, for each technique, for each configuration, the aggregated mape\\n run_tec_conf_set = recursivedict()\\n\\n # Hyperparameter search aggregating over folders\\n for conf in self._exp_confs:\\n run = int(conf.get_signature()[0].replace(\\\"run_\\\", \\\"\\\"))\\n fold = int(conf.get_signature()[2].replace(\\\"f\\\", \\\"\\\"))\\n technique = conf.technique\\n configuration = str(conf.get_signature()[4:])\\n if \\\"hp_selection\\\" not in run_tec_conf_set[run][technique][configuration]:\\n for set_name in set_names:\\n run_tec_conf_set[run][technique][configuration][set_name] = 0\\n for set_name in set_names:\\n run_tec_conf_set[run][technique][configuration][set_name] = run_tec_conf_set[run][technique][configuration][set_name] + conf.mapes[set_name] / folds\\n\\n # Select the best configuration for each technique across different folders\\n run_tec_best_conf = recursivedict()\\n for run in run_tec_conf_set:\\n for tec in run_tec_conf_set[run]:\\n for conf in run_tec_conf_set[run][tec]:\\n if tec not in run_tec_best_conf[run] or run_tec_conf_set[run][tec][conf][\\\"hp_selection\\\"] < run_tec_best_conf[run][tec][1][\\\"hp_selection\\\"]:\\n run_tec_best_conf[run][tec] = (conf, run_tec_conf_set[run][tec][conf])\\n\\n # Print results for each run\\n for run in range(0, self._campaign_configuration['General']['run_num']):\\n self._logger.info(\\\"Printing results for run %s\\\", run)\\n overall_run_best = () # (technique, configuration, mapes)\\n # Print data of single techniques\\n for technique in run_tec_best_conf[run]:\\n temp = run_tec_best_conf[run][technique]\\n self._logger.info(\\\"---Best result for %s - Configuration is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", technique, temp[0], temp[1][\\\"training\\\"], temp[1][\\\"hp_selection\\\"], temp[1][\\\"validation\\\"])\\n\\n # Compute which is the best technique\\n if not overall_run_best or temp[1][\\\"hp_selection\\\"] < overall_run_best[2][\\\"hp_selection\\\"]:\\n overall_run_best = (technique, temp[0], temp[1])\\n\\n self._logger.info(\\\"---Overall best result is %s %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", overall_run_best[0], overall_run_best[1], overall_run_best[2][\\\"training\\\"], overall_run_best[2][\\\"hp_selection\\\"], overall_run_best[2][\\\"validation\\\"])\\n\\n elif (validation, hp_selection) in {(\\\"KFold\\\", \\\"KFold\\\")}:\\n folds = float(self._campaign_configuration['General']['folds'])\\n # For each run, for each external fold, for each technique, the aggregated mape\\n run_efold_tec_conf_set = recursivedict()\\n\\n # Hyperparameter search aggregating over internal folders\\n for conf in self._exp_confs:\\n run = int(conf.get_signature()[0].replace(\\\"run_\\\", \\\"\\\"))\\n ext_fold = int(conf.get_signature()[2].replace(\\\"f\\\", \\\"\\\"))\\n technique = conf.technique\\n configuration = str(conf.get_signature()[4:])\\n if \\\"hp_selection\\\" not in run_tec_conf_set[run][technique][configuration]:\\n for set_name in set_names:\\n run_tec_conf_set[run][technique][configuration][set_name] = 0\\n for set_name in set_names:\\n run_tec_conf_set[run][technique][configuration][set_name] = run_tec_conf_set[run][technique][configuration][set_name] + (conf.mapes[set_name] / (folds * folds))\\n if configuration not in run_efold_tec_conf_set[run][ext_fold][technique]:\\n for set_name in set_names:\\n run_efold_tec_conf_set[run][ext_fold][technique][configuration][set_name] = 0\\n for set_name in set_names:\\n run_efold_tec_conf_set[run][ext_fold][technique][configuration][set_name] = run_efold_tec_conf_set[run][ext_fold][technique][configuration][set_name] + (conf.mapes[set_name] / (folds * folds))\\n\\n # Select the best configuration for each technique in each external fold across different internal folders\\n run_efold_tec_best_conf = recursivedict()\\n for run in run_efold_tec_conf_set:\\n for efold in run_efold_tec_conf_set[run]:\\n for tec in run_efold_tec_conf_set[run][efold]:\\n for conf in run_efold_tec_conf_set[run][efold][tec]:\\n if conf not in run_efold_tec_best_conf[run][efold][tec] or run_efold_tec_conf_set[run][efold][tec][conf][\\\"hp_selection\\\"] < run_efold_tec_best_conf[run][efold][tec][1][\\\"hp_selection\\\"]:\\n run_efold_tec_best_conf[run][efold][tec] = (conf, run_efold_tec_conf_set[run][efold][tec][conf], run_efold_tec_conf_set[run][efold][tec][conf])\\n\\n # Aggregate on external folds\\n run_tec_set = recursivedict()\\n for run in run_efold_tec_best_conf:\\n for efold in run_efold_tec_best_conf[run]:\\n for tec in run_efold_tec_best_conf[run][efold]:\\n if \\\"hp_selection\\\" not in run_tec_set[run][tec]:\\n for set_name in set_names:\\n run_tec_set[run][tec][set_name] = 0\\n for set_name in set_names:\\n run_tec_set[run][tec][set_name] = run_tec_set[run][tec][set_name] + run_efold_tec_best_conf[run][efold][tec][1][set_name]\\n\\n # Print results for each run\\n for run in range(0, self._campaign_configuration['General']['run_num']):\\n self._logger.info(\\\"Printing results for run %s\\\", run)\\n overall_run_best = ()\\n # Print data of single techniques\\n for technique in run_tec_set[run]:\\n self._logger.info(\\\"---Best result for %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", technique, run_tec_set[run][technique][\\\"training\\\"], run_tec_set[run][technique][\\\"hp_selection\\\"], run_tec_set[run][technique][\\\"validation\\\"])\\n\\n # Compute which is the best technique\\n if not overall_run_best or run_tec_set[run][technique][\\\"hp_selection\\\"] < overall_run_best[1][\\\"hp_selection\\\"]:\\n overall_run_best = (technique, run_tec_set[run][technique])\\n\\n self._logger.info(\\\"---Overall best result is %s - (Training MAPE is %f - HP Selection MAPE is %f) - Validation MAPE is %f\\\", overall_run_best[0], overall_run_best[1][\\\"training\\\"], overall_run_best[1][\\\"hp_selection\\\"], overall_run_best[1][\\\"validation\\\"])\\n\\n else:\\n self._logger.error(\\\"Unexpected combination: %s\\\", str((validation, hp_selection)))\\n sys.exit(1)\\n best_confs = {}\\n best_technique = None\\n for conf in self._exp_confs:\\n technique = conf.technique\\n if technique not in best_confs or conf.mapes[\\\"validation\\\"] < best_confs[technique].mapes[\\\"validation\\\"]:\\n best_confs[technique] = conf\\n for technique in best_confs:\\n if not best_technique or best_confs[technique].mapes[\\\"validation\\\"] < best_confs[best_technique].mapes[\\\"validation\\\"]:\\n best_technique = technique\\n if bool(self._campaign_configuration['General']['details']):\\n for run in run_tec_conf_set:\\n for tec in run_tec_conf_set[run]:\\n for conf in run_tec_conf_set[run][tec]:\\n assert \\\"hp_selection\\\" in run_tec_conf_set[run][tec][conf]\\n assert \\\"validation\\\" in run_tec_conf_set[run][tec][conf], \\\"training MAPE not found for \\\" + str(run) + str(tec) + str(conf)\\n self._logger.info(\\\"Run %s - Technique %s - Conf %s - Training MAPE %f - Test MAPE %f\\\", str(run), ec.enum_to_configuration_label[tec], str(conf), run_tec_conf_set[run][tec][conf][\\\"hp_selection\\\"], run_tec_conf_set[run][tec][conf][\\\"validation\\\"])\\n return best_confs, best_technique\",\n \"def postprocess2(scores, classes, bboxes, iou_threshold=0.2, score_threshold=0.5):\\n n = len(scores)\\n \\n count_per_class = {cls:0 for cls in classes}\\n bbox_per_class = {cls:[] for cls in classes}\\n score_per_class = {cls:[] for cls in classes}\\n\\n for i in range(n):\\n count_per_class[classes[i]] += 1\\n bbox_per_class[classes[i]] += [bboxes[i]]\\n score_per_class[classes[i]] += [scores[i]]\\n \\n det_num = 0\\n det_classes = [] \\n det_scores = []\\n det_bboxes = []\\n\\n for cls in count_per_class:\\n current_count = count_per_class[cls]\\n current_scores = np.array(score_per_class[cls], np.float32)\\n current_bboxes = np.array(bbox_per_class[cls], np.int32)\\n\\n idx = np.argsort(current_scores)[::-1]\\n sorted_scores = current_scores[idx]\\n sorted_bboxes = current_bboxes[idx]\\n\\n top_k_ids = []\\n size = 0\\n i = 0\\n\\n while i < current_count:\\n if sorted_scores[i] < score_threshold:\\n break\\n top_k_ids.append(i)\\n det_num += 1\\n det_classes.append(cls)\\n det_scores.append(sorted_scores[i])\\n det_bboxes.append(sorted_bboxes[i])\\n size += 1\\n i += 1\\n\\n while i < current_count:\\n tiled_bbox_i = np.tile(sorted_bboxes[i], (size, 1))\\n ious, iofs, ioss = iou_bbox(tiled_bbox_i, sorted_bboxes[top_k_ids])\\n max_iou = np.max(ious)\\n # max_iof = np.max(iofs)\\n # max_ios = np.max(ioss)\\n # temp = np.max((max_iof, max_ios))\\n if max_iou > iou_threshold:\\n i += 1\\n else:\\n break\\n\\n return det_num, np.array(det_scores, np.float32), np.array(det_classes, np.int32), np.array(det_bboxes, np.int32)\",\n \"def __calculate_agg_shap_scores(self):\\n self.agg_stats_timer = SimbaTimer(start=True)\\n for clf_state, clf_state_name in zip(range(2), [\\\"ABSENT\\\", \\\"PRESENT\\\"]):\\n self.results = {}\\n self.df_save_path = os.path.join(\\n self.shap_logs_path,\\n \\\"SHAP_summary_{}_{}_{}.csv\\\".format(\\n self.classifier_name, clf_state_name, self.datetime\\n ),\\n )\\n shap_clf_sliced = self.shap_df[\\n self.shap_df[self.classifier_name] == clf_state\\n ]\\n for feature_category, feature_time_bin in itertools.product(\\n self.unique_feature_category_names, self.unique_time_bin_names\\n ):\\n if feature_category not in self.results.keys():\\n self.results[feature_category] = {}\\n feature_names_sliced = list(\\n self.feature_categories_df.loc[\\n :, (feature_category, feature_time_bin)\\n ]\\n )\\n feature_names_sliced = [\\n x\\n for x in feature_names_sliced\\n if str(x) != \\\"nan\\\" and x in shap_clf_sliced\\n ]\\n self.results[feature_category][feature_time_bin] = round(\\n shap_clf_sliced[feature_names_sliced].sum(axis=1).mean() * 100, 6\\n )\\n self.__save_aggregate_scores()\\n self.agg_stats_timer.stop_timer()\\n self.visualization_timer = SimbaTimer(start=True)\\n\\n stdout_success(\\n msg=f\\\"Aggregate SHAP statistics saved in {self.shap_logs_path} directory\\\",\\n elapsed_time=self.agg_stats_timer.elapsed_time_str,\\n )\",\n \"def classify(self, testData):\\n guesses = []\\n self.posteriors = [] # Log posteriors are stored for later data analysis (autograder).\\n for datum in testData:\\n posterior = self.calculateLogJointProbabilities(datum)\\n guesses.append(posterior.argMax())\\n self.posteriors.append(posterior)\\n return guesses\",\n \"def train(self):\\n\\n # Step 1 - Obtain optimized weights for final model ------------------------------------------------------------\\n\\n t0 = time()\\n\\n # Check the training data for potential hazardous problems\\n self.check_training_samples()\\n\\n opt_results = pd.DataFrame()\\n kf_opt = StratifiedKFold(n_splits=self.kfold_cv, shuffle=True)\\n rep_str, opt_str = '', ''\\n\\n if self.verbose:\\n print('\\\\n\\\\n__ TRAINING STEP 1/2 \\\\_______________________________')\\n print(' \\\\ Train with reverse %d-fold CV - %d time(s) /\\\\n' % (self.kfold_cv, self.n_repeat))\\n\\n for i_rep in range(self.n_repeat):\\n\\n if self.verbose:\\n rep_str = '\\\\n_/--- Rep %d/%d' % (i_rep + 1, self.n_repeat)\\n\\n # Sample clf-net parameters to test\\n param = [\\n np.random.normal(loc=self.n_estimators,\\n scale=self.n_estimators*self.param_tune_scale,\\n size=self.kfold_cv),\\n np.random.normal(loc=self.min_impurity_decrease,\\n scale=self.min_impurity_decrease*self.param_tune_scale,\\n size=self.kfold_cv),\\n np.random.normal(loc=self.min_sample_leaf,\\n scale=np.ceil(self.min_sample_leaf*self.param_tune_scale),\\n size=self.kfold_cv),\\n ]\\n scores = list()\\n\\n for j_fold, (opt_idxs, cv_train_idxs) in enumerate(kf_opt.split(\\n X=self.datas[self.train_idx].nidx_train,\\n y=self.datas[self.train_idx].gen_labels(condense_labels=True))):\\n\\n if self.verbose:\\n print(rep_str + ' - CV %d/%d ---\\\\_____\\\\n' % (j_fold + 1, self.kfold_cv))\\n\\n # set clf-net parameters\\n self.n_estimators = param[0][j_fold]\\n self.min_impurity_decrease = param[1][j_fold]\\n self.min_sample_leaf = param[2][j_fold]\\n self.clf_net = self.gen_rfc()\\n\\n # Split data\\n opt_nidxs = np.array([self.datas[self.train_idx].nidx_train[i] for i in opt_idxs])\\n cv_train_nidxs = np.array([self.datas[self.train_idx].nidx_train[i] for i in cv_train_idxs])\\n\\n # Partition train/eval nidx for reverse k-fold CV training\\n _, _, opt_eval_nidxs, opt_train_nidxs = train_test_split(\\n np.zeros(len(opt_nidxs)),\\n opt_nidxs,\\n test_size=1/(self.kfold_cv - 1),\\n shuffle=True,\\n stratify=self.datas[self.train_idx].gen_labels(nidxs=opt_nidxs, condense_labels=True))\\n\\n # Train clfs\\n if self.verbose:\\n print('\\\\n> Training base classifiers ...')\\n self._train_clfs(train_nidxs=cv_train_nidxs)\\n\\n # Evaluate train with cv_train data\\n if self.verbose:\\n print('\\\\n> Evaluating base classifiers with cv_train partition ...')\\n self.clfs_predict(nidxs_target=cv_train_nidxs, data=self.datas[self.train_idx], to_eval=True,\\n eval_idx=self.train_idx)\\n\\n # Evaluate pre-optimization with opt_train data\\n if self.verbose:\\n print('\\\\n> Evaluating base classifiers with cv_eval partition ...')\\n cv_res = self.clfs_predict(nidxs_target=opt_train_nidxs, data=self.datas[self.train_idx], to_eval=True,\\n nidxs_train=cv_train_nidxs, eval_idx=self.train_idx)\\n\\n # Train clf-opt with opt_train partition results\\n if self.verbose:\\n print('\\\\n> Training clf-opt ...')\\n self._train_clf_opt(predictions=cv_res)\\n\\n # Evaluate clf-opt with opt_eval partition\\n if self.verbose:\\n print('\\\\n> Evaluating optimized classifier with opt_test partition ...')\\n opt_res = self.clfs_predict(nidxs_target=opt_eval_nidxs, data=self.datas[self.train_idx], to_eval=True,\\n nidxs_train=cv_train_nidxs, eval_idx=self.train_idx)\\n opt_results = opt_results.append(opt_res, ignore_index=True)\\n\\n # Append score to optimize clf-net parameter\\n r = self.scores(opt_res['ytruth'], opt_res['ynet'])\\n if not self.aim:\\n scores.append(r['aucroc'])\\n else:\\n aim = self.aim.replace('hard', '')\\n scores.append(r[aim])\\n\\n # reset link2featidx\\n self.datas[self.train_idx].link2featidx = {}\\n\\n # Aggregate results from clf-net parameter search\\n self._set_clf_net_param(param, scores)\\n\\n # STEP 2 - Train final model -----------------------------------------------------------------------------------\\n # .clf_opt is already trained through previous iterations by using warm_start\\n\\n if self.verbose:\\n print('\\\\n__ TRAINING STEP 2/2 \\\\_______________________________')\\n print(' \\\\ Train final model with all train data /\\\\n')\\n\\n # Train clfs with all the data\\n self._train_clfs()\\n\\n # Evaluate final clf-opt with all data\\n print('\\\\n> Evaluating final classifier ...')\\n self.clfs_predict(nidxs_target=self.datas[self.train_idx].nidx_train, to_eval=True, eval_idx=self.train_idx)\\n print('** Because this is evaluating with the training data, classifier performances should be very high.')\\n\\n # Assign model ID - this is here so that if retrained, it would be known that it is not the same model anymore\\n self.id = 'm_%s' % gen_id()\\n\\n if self.verbose:\\n te = (time() - t0) / 60\\n print('\\\\n Training took %.1f minutes on %d processors' % (te, os.cpu_count()))\\n print('\\\\n__ __________')\\n print(' \\\\ Training complete! /\\\\n')\\n\\n return opt_results\",\n \"def get_optimal_postprocess(loaders=None, runner=None, logdir: str = \\\"\\\"):\\n loaders[\\\"infer\\\"] = loaders[\\\"valid\\\"]\\n\\n runner.infer(\\n model=runner.model,\\n loaders=loaders,\\n callbacks=[\\n CheckpointCallback(resume=f\\\"{logdir}/checkpoints/best.pth\\\"),\\n InferCallback(),\\n ],\\n )\\n valid_masks = []\\n probabilities = np.zeros((2220, 350, 525))\\n for i, (batch, output) in enumerate(\\n zip(loaders[\\\"infer\\\"].dataset, runner.callbacks[0].predictions[\\\"logits\\\"])\\n ):\\n image, mask = batch\\n for m in mask:\\n if m.shape != (350, 525):\\n m = cv2.resize(m, dsize=(525, 350), interpolation=cv2.INTER_LINEAR)\\n valid_masks.append(m)\\n\\n for j, probability in enumerate(output):\\n if probability.shape != (350, 525):\\n probability = cv2.resize(\\n probability, dsize=(525, 350), interpolation=cv2.INTER_LINEAR\\n )\\n probabilities[i * 4 + j, :, :] = probability\\n\\n class_params = {}\\n for class_id in range(4):\\n print(class_id)\\n attempts = []\\n for t in range(0, 100, 10):\\n t /= 100\\n for ms in [\\n 0,\\n 100,\\n 1000,\\n 5000,\\n 10000,\\n 11000,\\n 14000,\\n 15000,\\n 16000,\\n 18000,\\n 19000,\\n 20000,\\n 21000,\\n 23000,\\n 25000,\\n 27000,\\n 30000,\\n 50000,\\n ]:\\n masks = []\\n for i in range(class_id, len(probabilities), 4):\\n probability = probabilities[i]\\n predict, num_predict = post_process(sigmoid(probability), t, ms)\\n masks.append(predict)\\n\\n d = []\\n for i, j in zip(masks, valid_masks[class_id::4]):\\n if (i.sum() == 0) & (j.sum() == 0):\\n d.append(1)\\n else:\\n d.append(dice(i, j))\\n\\n attempts.append((t, ms, np.mean(d)))\\n\\n attempts_df = pd.DataFrame(attempts, columns=[\\\"threshold\\\", \\\"size\\\", \\\"dice\\\"])\\n\\n attempts_df = attempts_df.sort_values(\\\"dice\\\", ascending=False)\\n print(attempts_df.head())\\n best_threshold = attempts_df[\\\"threshold\\\"].values[0]\\n best_size = attempts_df[\\\"size\\\"].values[0]\\n\\n class_params[class_id] = (best_threshold, int(best_size))\\n\\n print(class_params)\\n return class_params\",\n \"def getAllContributingAlgorithmsToBest(algnamelist, target_lb=1e-8, \\n target_ub=1e2):\\n \\n print \\\"Generating best algorithm data from given algorithm list...\\\\n\\\", \\n customgenerate(algnamelist)\\n \\n bestalgfilepath = 'bestCustomAlg'\\n picklefilename = os.path.join(bestalgfilepath, 'bestalg.pickle')\\n fid = open(picklefilename, 'r')\\n bestalgentries = pickle.load(fid)\\n fid.close()\\n print 'loading of best algorithm data done.'\\n \\n countsperalgorithm = {}\\n for (d, f) in bestalgentries:\\n print 'dimension:', d, ', function:', f\\n print f\\n setofalgs = set(bestalgentries[d,f].algs)\\n # pre-processing data to only look at targets >= target_lb:\\n correctedbestalgentries = []\\n for i in range(0,len(bestalgentries[d,f].target)):\\n if ((bestalgentries[d,f].target[i] >= target_lb) and\\n (bestalgentries[d,f].target[i] <= target_ub)):\\n \\n correctedbestalgentries.append(bestalgentries[d,f].algs[i])\\n print len(correctedbestalgentries)\\n # now count how often algorithm a is best for the extracted targets\\n for a in setofalgs:\\n # use setdefault to initialize with zero if a entry not existant:\\n countsperalgorithm.setdefault((d, a), 0) \\n countsperalgorithm[(d,a)] += correctedbestalgentries.count(a)\\n \\n selectedalgsperdimension = {}\\n for (d,a) in sorted(countsperalgorithm):\\n if not selectedalgsperdimension.has_key(d):\\n selectedalgsperdimension[d] = []\\n selectedalgsperdimension[d].append((countsperalgorithm[(d,a)], a))\\n \\n for d in sorted(selectedalgsperdimension):\\n print d, 'D:'\\n for (count, alg) in sorted(selectedalgsperdimension[d], reverse=True):\\n print count, alg\\n print '\\\\n'\\n \\n \\n print \\\" done.\\\"\",\n \"def train_all_categories(features, outputs, model, params_grid=None):\\n results = dict() \\n for output_class in outputs.keys():\\n output_class=\\\"ASSAULT\\\"\\n output = outputs[output_class]\\n\\n \\tdefault_model = model()\\n default_score = cross_validate(features, output, default_model)\\n\\n\\tprint(\\\"Fine Tuning for class %s\\\"%(output_class))\\n\\t\\n\\tfine_tune_model = fine_tune(features, output, model(), verbose=1, params_grid=params_grid,)\\n best_model, fine_tune_score = fine_tune_model.best_estimator_, fine_tune_model.best_score_\\n results[output_class] = [(default_model, default_score), (best_model, fine_tune_score)]\\n\\tbreak\\n return results\",\n \"def Bayes_prediction(X, y, fold_number=10):\\n D = X.shape[1]\\n fold = KFold(n_splits=fold_number)\\n cross_tab_all = []\\n lamb_hat_all = []\\n \\n for train_index, test_index in fold.split(X, y):\\n X_train, X_test = X.iloc[train_index], X.iloc[test_index]\\n y_train, y_test = y.iloc[train_index], y.iloc[test_index]\\n length = X_train.shape[0]\\n pi_hat = y_train.mean()\\n lamb_hat = np.zeros((2, D))\\n \\n for flag in range(2):\\n for d in range(D):\\n lamb_hat[flag][d] = (sum(X_train.iloc[i][d] * (y_train.iloc[i]==flag) for i in range(length))) / (sum(y_train.iloc[i]==flag for i in range(length)))\\n\\n y_pred = np.zeros(len(X_test))\\n for i in range(len(X_test)):\\n y_pred[i] = Bayes_classifier(pi_hat, X_test.iloc[i], lamb_hat)\\n \\n cross_tab = np.zeros((2, 2))\\n for m in [0, 1]:\\n for n in [0, 1]:\\n cross_tab[m][n] = sum([(y_test.values[i]==m) & (y_pred[i]==n) for i in range(len(y_pred))]) \\n \\n cross_tab_all.append(cross_tab)\\n lamb_hat_all.append(lamb_hat)\\n \\n cross_tab_all = sum(cross_tab_all)\\n lamb_hat_all\\n\\n return lamb_hat_all, cross_tab_all\",\n \"def compute_accuracy(data, num_labels = 4): \\n \\n # Declarating list to store results\\n accuracies = []\\n \\n for instance in data:\\n \\n # Declarating list to store individual results\\n instance_accuracies = []\\n \\n for i in np.arange(num_labels):\\n \\n # Computing and storing accuracy for each class\\n instance_accuracies.append(accuracy_score(instance[:, 2 + i], instance[:, 2 + i + 4]))\\n \\n # Storing mean results of the instance\\n accuracies.append(np.mean(instance_accuracies))\\n \\n # Returning mean of all results\\n return np.mean(accuracies)\",\n \"def random_objective(params, iteration, n_folds = N_FOLDS):\\n\\n start = timer()\\n \\n # Perform n_folds cross validation\\n cv_results = lgb.cv(params, train_set, num_boost_round = 10000, nfold = n_folds, \\n early_stopping_rounds = 100, metrics = 'l2', seed = 50, stratified=False)\\n end = timer()\\n best_score = np.max(cv_results['l2-mean'])\\n \\n # Loss must be minimized\\n loss = 1 - best_score\\n \\n # Boosting rounds that returned the highest cv score\\n n_estimators = int(np.argmax(cv_results['l2-mean']) + 1)\\n \\n # Return list of results\\n return [loss, params, iteration, n_estimators, end - start]\",\n \"def test_205_boosted_goal_difference_for_home_models_with_thresholds(self):\\n\\n def create_model_fn(fn_team: str):\\n team_stat = Stats.n_sample_stats_for_team(cursor=db_in_cursor,\\n team=fn_team,\\n last_sample_date=self.model_date,\\n n_samples=self.num_samples,\\n normalize_by_matches=True)\\n\\n\\n return FeatureModel(\\n input_data=[self.home_boost + team_stat.goal_diff, team_stat.goal_diff],\\n id=team_stat.team_name\\n )\\n\\n\\n for match_date in played_home_OR_away_before_dates:\\n ####\\n # Build model up to the day before the match\\n ####\\n self.home_boost = 0.72\\n self.model_date = match_date - timedelta(days=1)\\n self.num_samples = num_matches_in_season\\n\\n models: {str: FeatureModel} = FeatureModel.create_models_for_all_teams(\\n model_making_fn=create_model_fn, entities=teams)\\n\\n self.persist_models(model_gen_date=self.model_date, model_description=self.shortDescription(), models=models)\\n\\n self.make_and_store_predictions_for_date(match_date=match_date, models=models, draw_range=(-0.792, 1.945))\",\n \"def train_and_evaluate_k_fold(data_X, data_y, params, algo_factory, folds=5):\\n kf = KFold(n_splits=folds)\\n\\n accuracies = []\\n for train_index, test_index in kf.split(data_X):\\n learning_algo = algo_factory(params)\\n train_data_X, train_data_y = data_X[train_index], data_y[train_index]\\n test_data_X, test_data_y = data_X[test_index], data_y[test_index]\\n # Train\\n learning_algo.fit(train_data_X, train_data_y)\\n # Evaluate\\n accuracy = learning_algo.score(test_data_X, test_data_y)\\n # Save\\n accuracies.append(accuracy)\\n # return average accuracy\\n return np.mean(accuracies)\",\n \"def get_balancing_weight_factors(instances):\\n sum_continue = sum(w for _, classification, w in instances\\n if classification == Action.CONTINUE)\\n sum_turn_peak = sum(w for _, classification, w in instances\\n if classification == Action.TURN_PEAK)\\n sum_backtrack = sum(w for _, classification, w in instances\\n if classification == Action.BACKTRACK)\\n\\n min_sum = min(sum_continue, sum_turn_peak, sum_backtrack)\\n factors = { Action.CONTINUE : multiplier_continue *\\n float(min_sum) / sum_continue,\\n Action.TURN_PEAK : multiplier_turn_peak *\\n float(min_sum) / sum_turn_peak,\\n Action.BACKTRACK : multiplier_backtrack *\\n float(min_sum) / sum_backtrack }\\n return factors\",\n \"def get_metrics(cfg, model, X_anchor, y_anchor, X_gal, y_gal, annoy_index, vec_dim):\\n rank10_acc = 0\\n rank5_acc = 0\\n rank1_acc = 0\\n avg_acc = 0\\n vote_res = 0\\n\\n l2 = []\\n for anchor in range(0, len(X_anchor)):\\n res = get_result(get_image_features(cfg, model, X_anchor[anchor]), annoy_index)\\n vote = defaultdict(int)\\n # Accuracy\\n correct = 0\\n for i in res[:10]:\\n vote[y_gal[i]] += 1\\n\\n max_key = max(vote, key=vote.get)\\n if max_key == y_anchor[anchor]:\\n vote_res += 1\\n \\n\\n for recomm in res[:10]:\\n if y_gal[recomm] == y_anchor[anchor]:\\n correct += 1 \\n\\n avg_acc += correct/len(res)\\n\\n # Mean Average Precision\\n l1 = []\\n for recomm in res[:10]:\\n if y_gal[recomm] == y_anchor[anchor]:\\n correct += 1\\n l1.append(1)\\n else:\\n l1.append(0)\\n l2.append(l1) \\n\\n # Rank10 Accuracy\\n for each_val in res[:10]:\\n if y_gal[each_val] == y_anchor[anchor]:\\n rank10_acc += 1\\n break\\n \\n # Rank5 Accuracy\\n for each_val in res[:5]:\\n if y_gal[each_val] == y_anchor[anchor]:\\n rank5_acc += 1\\n break\\n\\n # Rank1 Accuracy\\n for each_val in res[:1]:\\n if y_gal[each_val] == y_anchor[anchor]:\\n rank1_acc += 1\\n break\\n\\n print(\\\"Avg acc is :: {avg_acc}\\\".format(avg_acc = avg_acc/len(X_anchor)))\\n print(\\\"Rank 10 acc is :: {rank10_acc}\\\".format(rank10_acc = rank10_acc/len(X_anchor)))\\n print(\\\"Rank 5 acc is :: {rank5_acc}\\\".format(rank5_acc = rank5_acc/len(X_anchor)))\\n print(\\\"Rank 1 acc is :: {rank1_acc}\\\".format(rank1_acc = rank1_acc/len(X_anchor)))\\n print(\\\"Mean Avg Precision is :: {mAP}\\\".format(mAP=mean_average_precision(l2)))\\n print(\\\"Vote res :: \\\", vote_res/len(X_anchor))\\n\\n return rank1_acc/len(X_anchor), mean_average_precision(l2)\",\n \"def strategy(hand, num_die_sides):\\n\\n possible_holds = gen_all_holds(hand)\\n best_val = 0\\n best_score = 0\\n dice_to_hold = []\\n\\n for hold in possible_holds:\\n hold_val = expected_value(hold, NUM_DIE_SIDES, NUM_DICE - len(hold))\\n\\n hand_score = score(hold) + score(hand)\\n if hand_score > best_val:\\n # best_val = hold_val\\n best_score = hand_score\\n dice_to_hold = hold\\n hand_copy = list(hand)\\n sugg_hand = hand_copy.append(dice_to_hold)\\n return (hand_score, sugg_hand)\",\n \"def get_num_boosting_rounds(self):\\n return self.n_estimators\",\n \"def balence_classes(df, btol):\\r\\n #Find the least supported class and muliply by the tolerance coefficient to get max_count:\\r\\n ccounts = df['classification'].value_counts()\\r\\n max_count = np.min(ccounts.values) * btol\\r\\n #Create a new dataframe with balenced support:\\r\\n newdf = pd.DataFrame(columns=df.columns.values)\\r\\n for x in df.groupby('classification'):\\r\\n if x[1].shape[0] > max_count:\\r\\n newdf = newdf.append(x[1].sample(max_count).reset_index(drop=True))\\r\\n else:\\r\\n newdf = newdf.append(x[1].reset_index(drop=True))\\r\\n return newdf.reset_index(drop=True)\",\n \"def findBestScore():\\n resultList = []\\n BestScore = 0\\n # iterate through different max_depths from 1 to 19\\n for max_depth in range(1,20):\\n dtree = tree.DecisionTreeClassifier(max_depth=max_depth)\\n trainng_score = []\\n testing_score = []\\n # run 10 different cross-validation\\n for index in range(10):\\n # split into cross-validation sets.\\n cv_data_train, cv_data_test, cv_target_train, cv_target_test = \\\\\\n cross_validation.train_test_split(X_train, y_train, test_size=0.1)\\n # fit the model using the cross-validation data\\n # and tune parameter, such as max_depth here\\n dtree = dtree.fit(cv_data_train, cv_target_train)\\n dtree.feature_importances_\\n trainng_score += [dtree.score(cv_data_train,cv_target_train)]\\n testing_score += [dtree.score(cv_data_test,cv_target_test)]\\n\\n # Compute the average score for both traning and testing data\\n trainng_avgScore = 1.0 * sum(trainng_score)/len(trainng_score)\\n testing_avgScore = 1.0 * sum(testing_score)/len(testing_score)\\n\\n # find the best score\\n if testing_avgScore > BestScore:\\n BestScore = testing_avgScore\\n best_depth = max_depth\\n resultList += [[best_depth, trainng_avgScore, testing_avgScore]]\\n print ('The best average score and the corresponding max_depth is: ')\\n return BestScore, best_depth\",\n \"def train_and_score_bagging(network):\\n\\n train_predictions = pd.read_pickle('data/train_predictions.pkl.gz', compression='gzip')\\n test_predictions = pd.read_pickle('data/test_predictions.pkl.gz', compression='gzip')\\n\\n train_actuals = pd.read_pickle('data/train_actuals.pkl.gz', compression='gzip')\\n test_actuals = pd.read_pickle('data/test_actuals.pkl.gz', compression='gzip')\\n\\n\\n train_x = np.array(train_predictions.values)\\n train_y = train_actuals[0].values\\n train_log_y = safe_log(train_y)\\n test_x = np.array(test_predictions.values)\\n test_y = test_actuals[0].values\\n test_log_y = safe_log(test_y)\\n\\n model = compile_model(network)\\n\\n print('\\\\rNetwork')\\n\\n for property in network:\\n print(property, ':', network[property])\\n logging.info('%s: %s' % (property, network[property]))\\n\\n test = xgb.DMatrix(test_x)\\n train = xgb.DMatrix(train_x, label=train_log_y)\\n\\n\\n\\n eval_set = [(test_x, test_log_y)]\\n model.fit(train_x, train_log_y, early_stopping_rounds=20, eval_metric='mae', eval_set=eval_set,\\n verbose=False)\\n\\n # eval_set = [(test, test_log_y)]\\n # xgb.train(network, train, num_boost_round=5000, evals=eval_set, early_stopping_rounds=5)\\n\\n predictions = model.predict(test_x)\\n # predictions = xgb.predict(test_x)\\n inverse_predictions = safe_exp(predictions)\\n score = mean_absolute_error(test_y, inverse_predictions)\\n mape = safe_mape(test_y, inverse_predictions)\\n\\n print('\\\\rResults')\\n\\n best_round = xgb.best_iteration\\n\\n if np.isnan(score):\\n score = 9999\\n\\n print('best round:', best_round)\\n print('loss:', score)\\n print('mape:', mape)\\n print('-' * 20)\\n\\n logging.info('best round: %d' % best_round)\\n logging.info('loss: %.4f' % score)\\n logging.info('mape: %.4f' % mape)\\n logging.info('-' * 20)\\n\\n eval_results({'xgb_predictions': {\\n 'actual_y': test_y,\\n 'y_predict': inverse_predictions\\n }\\n })\\n\\n range_results({\\n 'xgb_predictions': inverse_predictions,\\n }, test_y)\",\n \"def _mean_match_multiclass_accurate(\\n mean_match_candidates,\\n bachelor_preds,\\n candidate_preds,\\n candidate_values,\\n random_state,\\n hashed_seeds,\\n):\\n if mean_match_candidates == 0:\\n imp_values = np.argmax(bachelor_preds, axis=1)\\n\\n else:\\n _to_2d(bachelor_preds)\\n _to_2d(candidate_preds)\\n\\n num_bachelors = bachelor_preds.shape[0]\\n kd_tree = KDTree(candidate_preds, leafsize=16, balanced_tree=False)\\n _, knn_indices = kd_tree.query(\\n bachelor_preds, k=mean_match_candidates, workers=-1\\n )\\n\\n # We can skip the random selection process if mean_match_candidates == 1\\n if mean_match_candidates == 1:\\n index_choice = knn_indices\\n\\n else:\\n # Come up with random numbers 0-mean_match_candidates, with priority given to hashed_seeds\\n if hashed_seeds is None:\\n ind = random_state.randint(mean_match_candidates, size=(num_bachelors))\\n else:\\n ind = hashed_seeds % mean_match_candidates\\n\\n index_choice = knn_indices[np.arange(knn_indices.shape[0]), ind]\\n\\n imp_values = np.array(candidate_values)[index_choice]\\n\\n return imp_values\",\n \"def test_gbc(x, y, tune):\\n # Perform classification without tuning. It was determined through trial-and-error\\n # that log2 features produced the highest accuracy\\n gbt = GradientBoostingClassifier(max_features=\\\"log2\\\")\\n pipeline = create_pipeline(gbt)\\n return accuracy(pipeline, x, y)\",\n \"def classify( self, data):\\n\\n\\t\\t\\\"*** YOUR CODE HERE ***\\\"\\n\\t\\tguesses = np.zeros(len(data))\\n\\n\\t\\tfor k in range(len(self.classifiers)):\\n\\t\\t\\tclassifier = self.classifiers[k]\\n\\t\\t\\tguesses += np.dot(classifier.classify(data),self.alphas[k])\\n\\t\\t\\n\\t\\tguesses = np.sign(guesses)\\n\\t\\tguesses[np.where(guesses == 0)[0]] = np.repeat(np.expand_dims(np.random.choice([-1,1]),axis=0),len(np.where(guesses == 0)[0]),axis=0)\\n\\t\\treturn guesses\\n\\t\\t# util.raiseNotDefined()\",\n \"def optimal_instances_per_class(df, factor=1.0, draw=False):\\n # `bincount` returns the number of instances we have for each website\\n counts = np.bincount(df.class_label.tolist())\\n hist, bin_edges = np.histogram(counts)\\n if draw:\\n inst_counts = get_num_instances(df)\\n inst_counts.hist(cumulative=-1, bins=100)\\n plt.xlabel('Num of instances')\\n plt.ylabel('Num of classes with x or more insts')\\n plt.show()\\n\\n # scale the y-axis\\n dx = bin_edges[1] - bin_edges[0]\\n cum_hist = np.cumsum(hist) * dx\\n\\n # get the inverse cumulative sum\\n inv_cum_hist = max(cum_hist) - cum_hist\\n\\n # compute the harmonic mean of tuples (y=f(x), x)\\n hms = [harmonic_mean(x, y, factor) if y > 0 and x > 0 else 0\\n for x, y in zip(bin_edges[1:], inv_cum_hist)]\\n\\n print(hms)\\n\\n # find index for max harmonic mean\\n i = np.argmax(hms)\\n\\n # this is the optimal number of instances:\\n opt_num_insts = int(bin_edges[i])\\n\\n # which leaves us with this number of classes:\\n opt_num_classes = len(counts[counts >= opt_num_insts])\\n\\n if draw:\\n print(\\\"Optimal number of instances:\\\", opt_num_insts)\\n print(\\\"Optimal number of classes:\\\", opt_num_classes)\\n\\n return opt_num_insts, opt_num_classes\",\n \"def bin_class_grid_search(model_class, data_loader, hp_file,\\n loader_args=None, model_args=None,\\n folds=4, random_oversample=False):\\n loader = data_loader(**loader_args)\\n\\n # load index values from main table\\n data_ix = loader.get_index()\\n\\n # load hyperparameters from file\\n with open(hp_file, 'r') as f:\\n hyperparameters = ast.literal_eval(f.read())\\n\\n # create a list of dicts with hyperparameters for each experiment to run\\n keys, values = zip(*hyperparameters.items())\\n experiments = [dict(zip(keys, v)) for v in itertools.product(*values)]\\n exp_df = pd.DataFrame(experiments)\\n\\n # prepare for storing confusion matrix and accuracy results to file\\n cm = np.zeros((len(experiments), 2, 2), dtype=int)\\n cm_df_cols = ['CM True Neg', 'CM False Pos', 'CM False Neg', 'CM True Pos']\\n results_path = 'data/results/gridsearch_results_{:%Y%m%d_%H%M%S}.csv'.format(datetime.now())\\n\\n # fit model using k-fold verification\\n kf = KFold(n_splits=folds, shuffle=True)\\n\\n for j, fold_indexes in enumerate(kf.split(data_ix)):\\n # load train and validation data\\n data_train, target_train, data_val, target_val = loader.load_train_val(fold_indexes[0], fold_indexes[1])\\n\\n # determine shape of input arrays\\n input_shape = loader.get_input_shape()\\n\\n # oversample to correct for class imbalance\\n if random_oversample:\\n ros = RandomOverSampler()\\n os_index, target_train = ros.fit_sample(np.arange(len(fold_indexes[0])).reshape(-1, 1), target_train)\\n if isinstance(data_train, list):\\n data_train = [data_train_part[os_index.squeeze()] for data_train_part in data_train]\\n else:\\n data_train = data_train[os_index.squeeze()]\\n\\n logging.debug('Fold {} of {}'.format(j + 1, folds))\\n\\n for i, experiment in enumerate(experiments):\\n logging.debug(experiment)\\n model = model_class(input_shape, **model_args, **experiment)\\n # TODO: track oos accuracy per epoch\\n history = model.fit(data_train, target_train, validation_data=(data_val, target_val))\\n predict_val = model.predict(data_val)\\n\\n cm[i, :, :] = cm[i, :, :] + confusion_matrix(target_val, predict_val.round())\\n cm_df = pd.DataFrame(cm.reshape((cm.shape[0], 4)), columns=cm_df_cols)\\n results_df = exp_df.join(cm_df)\\n # TODO: also store run time\\n results_df.to_csv(results_path)\",\n \"def train_epoch(self):\\n # We can't validate a winner for submissions generated by the learner,\\n # so we will use a winner-less match when getting rewards for such states\\n blank_match = {\\\"winner\\\":None}\\n\\n learner_submitted_actions = 0\\n null_actions = 0\\n\\n # Shuffle match presentation order\\n if(self.N_TEMP_TRAIN_MATCHES):\\n path_to_db = \\\"../data/competitiveMatchData.db\\\"\\n sources = {\\\"patches\\\":self.TEMP_TRAIN_PATCHES, \\\"tournaments\\\":[]}\\n print(\\\"Adding {} matches to training pool from {}.\\\".format(self.N_TEMP_TRAIN_MATCHES, path_to_db))\\n temp_matches = pool.match_pool(self.N_TEMP_TRAIN_MATCHES, path_to_db, randomize=True, match_sources=sources)[\\\"matches\\\"]\\n else:\\n temp_matches = []\\n data = self.training_data + temp_matches\\n\\n shuffled_matches = random.sample(data, len(data))\\n for match in shuffled_matches:\\n for team in self.teams:\\n # Process match into individual experiences\\n experiences = mp.process_match(match, team)\\n for pick_id, experience in enumerate(experiences):\\n # Some experiences include NULL submissions (usually missing bans)\\n # The learner isn't allowed to submit NULL picks so skip adding these\\n # to the buffer.\\n state,actual,_,_ = experience\\n (cid,pos) = actual\\n if cid is None:\\n null_actions += 1\\n continue\\n # Store original experience\\n self.replay.store([experience])\\n self.step_count += 1\\n\\n # Give model feedback on current estimations\\n if(self.step_count > self.observations):\\n # Let the network predict the next action\\n feed_dict = {self.ddq_net.online_ops[\\\"input\\\"]:[state.format_state()],\\n self.ddq_net.online_ops[\\\"valid_actions\\\"]:[state.get_valid_actions()]}\\n q_vals = self.ddq_net.sess.run(self.ddq_net.online_ops[\\\"valid_outQ\\\"], feed_dict=feed_dict)\\n sorted_actions = q_vals[0,:].argsort()[::-1]\\n top_actions = sorted_actions[0:4]\\n\\n if(random.random() < self.epsilon):\\n pred_act = random.sample(list(top_actions), 1)\\n else:\\n # Use model's top prediction\\n pred_act = [sorted_actions[0]]\\n\\n for action in pred_act:\\n (cid,pos) = state.format_action(action)\\n if((cid,pos)!=actual):\\n pred_state = deepcopy(state)\\n pred_state.update(cid,pos)\\n r = get_reward(pred_state, blank_match, (cid,pos), actual)\\n new_experience = (state, (cid,pos), r, pred_state)\\n\\n self.replay.store([new_experience])\\n learner_submitted_actions += 1\\n\\n if(self.epsilon > 0.1):\\n # Reduce epsilon over time\\n self.epsilon -= self.eps_decay_rate\\n\\n # Use minibatch sample to update online network\\n if(self.step_count > self.pre_training_steps):\\n self.train_step()\\n\\n if(self.step_count % self.target_update_frequency == 0):\\n # After the online network has been updated, update target network\\n _ = self.ddq_net.sess.run(self.ddq_net.target_ops[\\\"target_update\\\"])\\n\\n # Get training loss, training_acc, and val_acc to return\\n loss, train_acc = self.validate_model(self.training_data)\\n _, val_acc = self.validate_model(self.validation_data)\\n return (loss, train_acc, val_acc)\",\n \"def algo_CVmetrics(classifier_object, X_train, Y_train):\\r\\n \\r\\n cv = RepeatedStratifiedKFold(n_splits = 5, n_repeats = 3, random_state = seed_custom)\\r\\n \\r\\n metricslist = {'f2': make_scorer(metrics.fbeta_score, beta = 2), \\r\\n 'balacc': make_scorer(metrics.balanced_accuracy_score),\\r\\n 'precision': make_scorer(metrics.precision_score),\\r\\n 'recall': make_scorer(metrics.recall_score)}\\r\\n \\r\\n cv_results = cross_validate(classifier_object, X_train, Y_train, cv = cv, scoring = metricslist, return_estimator = True)\\r\\n \\r\\n f2_mean = np.mean(cv_results['test_f2'])\\r\\n f2_std = np.std(cv_results['test_f2'])\\r\\n \\r\\n balacc_mean = np.mean(cv_results['test_balacc'])\\r\\n balacc_std = np.std(cv_results['test_balacc'])\\r\\n\\r\\n precision_mean = np.mean(cv_results['test_precision'])\\r\\n precision_std = np.std(cv_results['test_precision'])\\r\\n \\r\\n recall_mean = np.mean(cv_results['test_recall'])\\r\\n recall_std = np.std(cv_results['test_recall'])\\r\\n \\r\\n scorebox = pd.DataFrame(np.zeros((1,8)), columns = list(['F2-Score Mean', 'F2-Score STD', 'Balanced Accuracy Mean', 'Balanced Accuracy STD',\\r\\n 'Precision Mean', 'Precision STD', 'Recall Mean', 'Recall STD']))\\r\\n \\r\\n scorebox.iloc[0,0] = f2_mean\\r\\n scorebox.iloc[0,1] = f2_std\\r\\n scorebox.iloc[0,2] = balacc_mean\\r\\n scorebox.iloc[0,3] = balacc_std\\r\\n scorebox.iloc[0,4] = precision_mean\\r\\n scorebox.iloc[0,5] = precision_std\\r\\n scorebox.iloc[0,6] = recall_mean\\r\\n scorebox.iloc[0,7] = recall_std \\r\\n \\r\\n scorebox = np.round(scorebox, 3)\\r\\n \\r\\n print(\\\"Model has a mean CV balanced accuracy of {0}, (Std: {1})\\\".format(round(balacc_mean,3), round(balacc_std,3)))\\r\\n print(\\\"Model has a mean CV F2_Score of {0}, (Std: {1})\\\".format(round(f2_mean,3), round(f2_std,3)))\\r\\n print(\\\"Model has a mean CV Precision of {0}, (Std: {1})\\\".format(round(precision_mean,3), round(precision_std,3)))\\r\\n print(\\\"Model has a mean CV Recall of {0}, (Std: {1})\\\".format(round(recall_mean,3), round(recall_std,3)))\\r\\n \\r\\n return scorebox\",\n \"def calculate_average_run_accuracy(self):\\n overall_true_rate, true_positive_rate, true_negative_rate, false_positive_rate, false_negative_rate, true_positive_rate_cutoff, true_negative_rate_cutoff, \\\\\\n false_positive_rate_cutoff, false_negative_rate_cutoff, unclassified_cutoff, matthews_correlation_coefficient, brier_score, auc_score, fit_time, hmeasure = [0] * 15\\n balanced_accuracy_arr = []\\n auc_arr = []\\n hmeasure_arr = []\\n brier_score_arr = []\\n fit_time_arr = []\\n mcc_arr = []\\n true_positive_arr = []\\n true_negative_arr = []\\n false_positive_arr = []\\n false_negative_arr = []\\n\\n count = 0\\n for result_dictionary in self.errors:\\n for z in range(len(result_dictionary[\\\"balanced_accuracy_arr\\\"])):\\n overall_true_rate += result_dictionary[\\\"balanced_accuracy_arr\\\"][z]\\n true_positive_rate += result_dictionary[\\\"true_positive_rate_arr\\\"][z]\\n true_negative_rate += result_dictionary[\\\"true_negative_rate_arr\\\"][z]\\n false_positive_rate += result_dictionary[\\\"false_positive_rate_arr\\\"][z]\\n false_negative_rate += result_dictionary[\\\"false_negative_rate_arr\\\"][z]\\n matthews_correlation_coefficient += result_dictionary[\\\"mcc_arr\\\"][z]\\n auc_score += result_dictionary[\\\"auc_arr\\\"][z]\\n brier_score += result_dictionary[\\\"brier_score_arr\\\"][z]\\n fit_time += result_dictionary[\\\"fit_time_arr\\\"][z]\\n hmeasure += result_dictionary[\\\"hmeasure_arr\\\"][z]\\n count += 1\\n\\n true_positive_rate_cutoff += result_dictionary[\\\"avg_true_positive_rate_with_prob_cutoff\\\"]\\n true_negative_rate_cutoff += result_dictionary[\\\"avg_true_negative_rate_with_prob_cutoff\\\"]\\n false_positive_rate_cutoff += result_dictionary[\\\"avg_false_positive_rate_with_prob_cutoff\\\"]\\n false_negative_rate_cutoff += result_dictionary[\\\"avg_false_negative_rate_with_prob_cutoff\\\"]\\n unclassified_cutoff += result_dictionary[\\\"avg_false_negative_rate_with_prob_cutoff\\\"]\\n balanced_accuracy_arr += result_dictionary[\\\"balanced_accuracy_arr\\\"]\\n hmeasure_arr += result_dictionary[\\\"hmeasure_arr\\\"]\\n auc_arr += result_dictionary[\\\"auc_arr\\\"]\\n brier_score_arr += result_dictionary[\\\"brier_score_arr\\\"]\\n fit_time_arr += result_dictionary[\\\"fit_time_arr\\\"]\\n mcc_arr += result_dictionary[\\\"mcc_arr\\\"]\\n true_positive_arr += result_dictionary[\\\"true_positive_rate_arr\\\"]\\n true_negative_arr += result_dictionary[\\\"true_negative_rate_arr\\\"]\\n false_positive_arr += result_dictionary[\\\"false_positive_rate_arr\\\"]\\n false_negative_arr += result_dictionary[\\\"false_negative_rate_arr\\\"]\\n\\n avg_run_results = [None] * 31\\n avg_run_results[0] = matthews_correlation_coefficient / float(count)\\n avg_run_results[1] = brier_score / float(count)\\n avg_run_results[2] = overall_true_rate / float(count)\\n avg_run_results[3] = true_positive_rate / float(count)\\n avg_run_results[4] = true_negative_rate / float(count)\\n avg_run_results[5] = false_positive_rate / float(count)\\n avg_run_results[6] = false_negative_rate / float(count)\\n avg_run_results[7] = true_positive_rate_cutoff / float(len(self.errors))\\n avg_run_results[8] = true_negative_rate_cutoff / float(len(self.errors))\\n avg_run_results[9] = false_positive_rate_cutoff / float(len(self.errors))\\n avg_run_results[10] = false_negative_rate_cutoff / float(len(self.errors))\\n avg_run_results[11] = unclassified_cutoff / float(len(self.errors))\\n avg_run_results[12] = fit_time / float(count)\\n avg_run_results[14] = balanced_accuracy_arr\\n avg_run_results[15] = auc_score / float(count)\\n avg_run_results[16] = auc_arr\\n avg_run_results[17] = brier_score_arr\\n avg_run_results[18] = fit_time_arr\\n avg_run_results[19] = mcc_arr\\n avg_run_results[13] = self.calculate_std_deviation(balanced_accuracy_arr)\\n avg_run_results[20] = self.calculate_std_deviation(mcc_arr)\\n avg_run_results[21] = self.calculate_std_deviation(brier_score_arr)\\n avg_run_results[22] = self.calculate_std_deviation(auc_arr)\\n avg_run_results[23] = self.calculate_std_deviation(fit_time_arr)\\n avg_run_results[24] = self.calculate_std_deviation(true_positive_arr)\\n avg_run_results[25] = self.calculate_std_deviation(true_negative_arr)\\n avg_run_results[26] = self.calculate_std_deviation(false_positive_arr)\\n avg_run_results[27] = self.calculate_std_deviation(false_negative_arr)\\n avg_run_results[28] = hmeasure / float(count)\\n avg_run_results[29] = self.calculate_std_deviation(hmeasure_arr)\\n avg_run_results[30] = hmeasure_arr\\n\\n return avg_run_results\",\n \"def _mean_match_multiclass_fast(\\n mean_match_candidates, bachelor_preds, random_state, hashed_seeds\\n):\\n if mean_match_candidates == 0:\\n imp_values = np.argmax(bachelor_preds, axis=1)\\n\\n else:\\n num_bachelors = bachelor_preds.shape[0]\\n\\n # Turn bachelor_preds into discrete cdf:\\n bachelor_preds = bachelor_preds.cumsum(axis=1)\\n\\n # Randomly choose uniform numbers 0-1\\n if hashed_seeds is None:\\n # This is the fastest way to adjust for numeric\\n # imprecision of float16 dtype. Actually ends up\\n # barely taking any time at all.\\n bp_dtype = bachelor_preds.dtype\\n unif = np.minimum(\\n random_state.uniform(0, 1, size=num_bachelors).astype(bp_dtype),\\n bachelor_preds[:, -1],\\n )\\n else:\\n unif = []\\n for i in range(num_bachelors):\\n np.random.seed(seed=hashed_seeds[i])\\n unif.append(np.random.uniform(0, 1, size=1)[0])\\n unif = np.array(unif)\\n\\n # Choose classes according to their cdf.\\n # Distribution will match probabilities\\n imp_values = np.array(\\n [\\n np.searchsorted(bachelor_preds[i, :], unif[i])\\n for i in range(num_bachelors)\\n ]\\n )\\n\\n return imp_values\",\n \"def evaluate(clf, dataset, feature_list, features, labels, num_iter, params):\\n\\n features_train, features_test, labels_train, labels_test = \\\\\\n train_test_split(features, labels, test_size=0.3, random_state=42)\\n\\n\\n\\n precision_values = []\\n recall_values = []\\n accuracy_values = []\\n print clf\\n for i in xrange(0, num_iter):\\n #print params\\n clf = GridSearchCV(clf, params)\\n clf.fit(features_train, labels_train)\\n print '*****************************'\\n print clf.best_estimator_\\n print clf.best_params_\\n\\n clf = clf.best_estimator_\\n #test_classifier(clf, dataset, feature_list)\\n pred = clf.predict(features_test)\\n precision_values.append(precision_score(labels_test, pred))\\n recall_values.append(recall_score(labels_test, pred))\\n accuracy_values.append(accuracy_score(labels_test, pred))\\n print 'Recall score: ', mean(recall_values)\\n print 'Precision score: ', mean(precision_values)\\n print 'Accuracy score: ' , mean(accuracy_values)\",\n \"def get_balancing_probabilities(instances):\\n count_continue = sum(classification == Action.CONTINUE \\n for _, classification in instances)\\n count_turn_peak = sum(classification == Action.TURN_PEAK\\n for _, classification in instances)\\n count_backtrack = sum(classification == Action.BACKTRACK\\n for _, classification in instances)\\n\\n min_count = min(count_continue, count_turn_peak, count_backtrack)\\n probabilities = { Action.CONTINUE : multiplier_continue * \\n float(min_count) / count_continue,\\n Action.TURN_PEAK : multiplier_turn_peak * \\n float(min_count) / count_turn_peak,\\n Action.BACKTRACK : multiplier_backtrack *\\n float(min_count) / count_backtrack }\\n return probabilities\",\n \"def best_threshold_from_folds(y_tuples, scoring=f1_score, step_size=0.01, maximize=True):\\n thresholds, scores = [], []\\n for _, y_true, y_pred in y_tuples:\\n t, s = find_best_threshold(y_true, y_pred, step_size, scoring, maximize=maximize)\\n thresholds.append(t)\\n scores.append(s)\\n\\n mean_threshold = np.mean(thresholds)\\n mean_score = np.mean([score_for_threshold(y, y_hat, scoring, mean_threshold) for _, y, y_hat in y_tuples])\\n return mean_threshold, mean_score\",\n \"def findRFBestN():\\n resultList = []\\n BestScore = 0\\n nList = [ n for n in range(1,200) if n%10 == 0]\\n for n in nList:\\n rforest = ensemble.RandomForestClassifier(max_depth=5, n_estimators=n)\\n trainng_score = []\\n testing_score = []\\n # run 10 different cross-validation\\n for index in range(10):\\n # split into cross-validation sets.\\n cv_data_train, cv_data_test, cv_target_train, cv_target_test = \\\\\\n cross_validation.train_test_split(X_train, y_train, test_size=0.1)\\n\\n # fit the model using the cross-validation data\\n # and tune parameter, such as max_depth here\\n rforest = rforest.fit(cv_data_train, cv_target_train)\\n trainng_score += [rforest.score(cv_data_train,cv_target_train)]\\n testing_score += [rforest.score(cv_data_test,cv_target_test)]\\n\\n # Compute the average score for both traning and testing data\\n trainng_avgScore = 1.0 * sum(trainng_score)/len(trainng_score)\\n testing_avgScore = 1.0 * sum(testing_score)/len(testing_score)\\n\\n # find the best score\\n if testing_avgScore > BestScore:\\n BestScore = testing_avgScore\\n best_n = n\\n resultList += [[n, trainng_avgScore, testing_avgScore]]\\n print ('The best average score and the corresponding n_estimator is: ')\\n return BestScore, best_n\",\n \"def evaluation_detections(thresholds, bboxes_gt, bboxes_detected, num_instances):\\r\\n TP = np.zeros(len(thresholds), dtype=int)\\r\\n FP = np.zeros(len(thresholds), dtype=int)\\r\\n\\r\\n scores_detections = [[] for i in range(len(thresholds))]\\r\\n # scores_detections is pair of values [result, confidence] where result is true if the example is correctly\\r\\n # classified and confidence is the confidence of the prediction. It's used to compute the precision-recall\\r\\n # curve. Confidence score is random if the predicted scores do not belong to a detector.\\r\\n\\r\\n for key in bboxes_detected.keys():\\r\\n for bbox_noisy in bboxes_detected[key]:\\r\\n if key in bboxes_gt: # if we have detected stuff and it is in the gt\\r\\n scores = [bbox_iou(bbox_noisy[1:5], bbox[1:5]) for bbox in bboxes_gt[key]]\\r\\n max_score = max(scores)\\r\\n for i, threshold in enumerate(thresholds):\\r\\n if max_score > threshold:\\r\\n TP[i] += 1\\r\\n # we give correct boxes a slightly higher confidence score\\r\\n scores_detections[i].append([1, bbox_noisy[5]])\\r\\n else:\\r\\n FP[i] += 1\\r\\n scores_detections[i].append([0, bbox_noisy[5]])\\r\\n else: # if we have detected stuff and it is not in the gt\\r\\n for i, threshold in enumerate(thresholds):\\r\\n FP[i] += 1\\r\\n\\r\\n FN = num_instances - TP # number of instances not detected\\r\\n return TP, FP, FN, np.array(scores_detections)\",\n \"def runUCB(self):\\n \\n #Init vars, N number of user sessions, d=number of ads\\n N = self.myDS.shape[0] \\n d = self.myDS.shape[1] \\n total_reward=0\\n self.opt_selected=[]\\n \\n #Declare vars to count to calculate upper bounds\\n numbers_of_selections = [0] * d\\n sums_of_rewards = [0] * d\\n \\n #Calcultate confidance bounds\\n for n in range(0,N):\\n ad=0\\n max_upper_bound=0\\n for i in range (0,d):\\n if (numbers_of_selections[i]>0):\\n average_reward=sums_of_rewards[i]/numbers_of_selections[i]\\n delta_i=math.sqrt(3/2 * math.log(n+1) / numbers_of_selections[i])\\n upper_bound=average_reward+delta_i\\n else:\\n upper_bound=1e400\\n if upper_bound>max_upper_bound:\\n max_upper_bound=upper_bound\\n ad = i\\n self.opt_selected.append(ad)\\n numbers_of_selections[ad]=numbers_of_selections[ad]+1\\n reward=self.myDS.values[n,ad]\\n sums_of_rewards[ad]=sums_of_rewards[ad]+reward\\n total_reward=total_reward+reward\\n \\n return total_reward\",\n \"def BayesPaperStats(maxIters, numRuns):\\n\\n comm = MPI.COMM_WORLD\\n rank = comm.Get_rank()\\n\\n assert comm.Get_size() == numRuns, \\\"Please ensure there is one process running per run i.e \\\" + str(numRuns) + \\\" processes.\\\"\\n \\n problemBounds = {\\\"Bfield\\\": choco.uniform(10, 1300), \\\"T\\\": choco.uniform(50, 230), \\\"Btheta\\\": choco.uniform(0, 90), \\\"Etheta\\\": choco.uniform(0, 90)}\\n\\n # The target for each algorithm. This was determined by using the values in the literature, so there is clearly some deviation either due to the detuning or computation.\\n globalFoM = 1.033\\n\\n if rank == 0:\\n timeList = []\\n iterationList = []\\n\\n # Set up the database for the chocolate optimiser.\\n connection = choco.SQLiteConnection(\\\"sqlite:///bayes_paper_\\\" + str(rank) + \\\"_db.db\\\")\\n\\n # Define which solver will be used.\\n solver = choco.Bayes(connection, problemBounds, utility_function = \\\"ei\\\", n_bootstrap = int(np.ceil(maxIters/10)), clear_db = True)\\n\\n # Clear the database. TODO: To do this?\\n connection.clear()\\n\\n # Start timing.\\n startTime = time.time()\\n timeElapsed = None\\n iterationSuccess = None\\n\\n # Start optimisation.\\n for iteration in range(maxIters):\\n\\n # Make one suggestion.\\n try:\\n token, nextParams = solver.next()\\n except:\\n print(\\\"Error suggesting a new point. Here are the last set of parameters sampled:\\\")\\n print(str(nextParams))\\n print(\\\"Iteration number: \\\" + str(iteration))\\n continue\\n\\n # Check what FoM this gives. Go negative as this is a minimisation routine.\\n fEval = abs(FitnessPaper(**nextParams))\\n\\n # Update best FoM.\\n if fEval >= globalFoM:\\n # The algorithm has managed to surpass or equal the paper value.\\n iterationSuccess = iteration\\n timeElapsed = time.time() - startTime\\n \\n if rank == 0:\\n iterationList.append(iterationSuccess)\\n timeList.append(timeElapsed)\\n\\n break\\n \\n # Tell the optimiser about the result.\\n solver.update(token, fEval)\\n\\n # Run complete. Send results to main process. Tags are unique identifiers.\\n if rank != 0:\\n comm.send(timeElapsed, dest = 0, tag = 1)\\n comm.send(iterationSuccess, dest = 0, tag = 2)\\n\\n # Wait for all the processes to end.\\n comm.Barrier()\\n\\n if rank == 0:\\n # Aggregate the data.\\n for process in range(comm.Get_size() - 1):\\n # Get the data.\\n individualTime = None\\n individualTime = comm.recv(individualTime, source = process + 1, tag = 1)\\n\\n individualIter = None\\n individualIter = comm.recv(individualIter, source = process + 1, tag = 2)\\n\\n if individualIter is not None:\\n # Both values must therefore be non-null.\\n iterationList.append(individualIter)\\n timeList.append(individualTime)\\n\\n avgRuntime = np.average(timeList)\\n avgIters = np.average(iterationList)\\n try:\\n\\n fastestTime = np.min(timeList)\\n\\n except ValueError:\\n \\n # List is empty.\\n fastestTime = float('NaN')\\n\\n numSuccess = len(iterationList)\\n successRate = numSuccess/numRuns\\n\\n print(\\\"Bayesian optimisation paper testing complete! Here are the stats:\\\")\\n print(\\\"Number of successful runs: \\\" + str(numSuccess) + \\\" (Success rate of \\\" + str(successRate) + \\\")\\\")\\n print(\\\"Average iterations required for success: \\\" + str(avgIters))\\n print(\\\"Average time required for success: \\\" + str(avgRuntime))\\n print(\\\"Fastest convergence time: \\\" + str(fastestTime))\\n print(\\\"------------------------------------------------------------------------------------------------------------------\\\")\\n \\n return\",\n \"def get_combinations(classes_folder='./data/CASIA1_classes_by_unbalanced_kmeans/', \\n originals='./data/CASIA1_originals', fakes_ela='./data/CASIA1_fakes_ela'):\\n classes_ = []\\n for i in range(20):\\n classes_.append('{}{}' .format(classes_folder, i+1))\\n\\n medians_ = [0,3,5,7,9,11,13,15,17,19]\\n\\n iterations_ = []\\n for i in range(21):\\n iterations_.append(i)\\n\\n threshold_ = []\\n for i in range(40):\\n threshold_.append(i)\\n\\n for i, item in enumerate(classes_):\\n fakes_list = os.listdir(item)\\n fakes = load_fakes(fakes_list, item, originals)\\n\\n best = 0\\n best_median_filter_size = 0\\n best_number_of_iterations = 0\\n best_thresh = 0\\n for x, median_filter_size in enumerate(medians_):\\n for y, number_of_iterations in enumerate(iterations_):\\n for t, thresh in enumerate(threshold_):\\n whole_score = 0\\n for e, elem in enumerate(fakes):\\n image = cv2.imread(os.path.join(fakes_ela, elem.path.split('\\\\\\\\')[-1]))\\n\\n if thresh > 0:\\n image_ = pywt.threshold(image, thresh, 'soft')\\n image = cv2.normalize(image_, image, 0, 1, cv2.NORM_MINMAX)\\n image = 255 * image\\n image = image.astype(np.uint8)\\n\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\\n \\n image = cv2.inRange(image, np.array([0,0,0]), np.array([180,255,60]))\\n image = cv2.bitwise_not(image)\\n\\n if median_filter_size > 0:\\n image = cv2.medianBlur(image, median_filter_size)\\n\\n kernel = np.ones((3, 3), np.uint8)\\n image = cv2.morphologyEx(image, cv2.MORPH_GRADIENT, kernel, iterations=number_of_iterations)\\n\\n cnts = cv2.findContours(image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n cnts = imutils.grab_contours(cnts)\\n\\n max_idx = 0\\n max_pnts = 0\\n for u, ulem in enumerate(cnts):\\n if cv2.contourArea(ulem) < max_pnts:\\n continue\\n else:\\n max_idx = u\\n max_pnts = cv2.contourArea(ulem)\\n\\n if len(cnts) > 0:\\n (x, y, w, h) = cv2.boundingRect(cnts[max_idx])\\n pred = {\\n \\\"x\\\": x,\\n \\\"y\\\": y,\\n \\\"w\\\": w,\\n \\\"h\\\": h\\n }\\n else:\\n pred = None\\n\\n whole_score += evaluate_augmentation_fit(pred, elem)\\n if best < whole_score:\\n best = whole_score\\n best_median_filter_size = median_filter_size\\n best_number_of_iterations = number_of_iterations\\n best_thresh = thresh\\n print(\\\"Class: {}; MedianFilterSize: {}; Iterations: {}; Thresh: {}; Score: {}\\\" .format(item, median_filter_size, number_of_iterations, thresh, round(whole_score, 2)))\\n print(\\\"###########\\\")\\n print(\\\"Best: {} -> {} % ({}, {}, {})\\\" .format(round(best, 2), round((best/len(fakes)), 2), best_median_filter_size, best_number_of_iterations, best_thresh))\\n print(\\\"###########\\\")\",\n \"def learn_with_bootstrapping(self, sample_count=10000):\\n tic = time.clock()\\n training_set_size = 150 # TODO: change to 1000, 500 or something\\n sample_pool = self.training_stream.extract_training_patches(sample_count, negative_ratio=1.)\\n # initialize weights\\n weighted_patches = []\\n for patch in sample_pool: # weight all patches: training pool P\\n weighted_patches.append([patch, 1. / len(sample_pool)])\\n # if patch.label == +1:\\n # pos_patch = patch # PRESENTATION, REPORT\\n # shuffle training pool\\n weighted_patches = random_sample_weighted_patches(weighted_patches, len(weighted_patches))\\n\\n if self.algorithm == 'adaboost': # Shuffle the training data\\n training_data = random_sample_weighted_patches(weighted_patches, len(weighted_patches))\\n elif self.algorithm == 'wald': # Sample training_set_size samples\\n training_data = random_sample_weighted_patches(weighted_patches, training_set_size)\\n\\n for t in range(self.layers): # choose the weak classifier with the minimum error\\n print \\\"Learn with bootstrapping using %s, layer #%d\\\" % (self.algorithm.title(), t+1)\\n\\n if self.algorithm == 'adaboost':\\n h_t = self._fetch_best_weak_classifier(weighted_patches)\\n elif self.algorithm == 'wald':\\n h_t = self._fetch_best_weak_classifier(training_data)\\n # h_t.visualize(pos_patch) # PRESENTATION, REPORT\\n self.classifiers.append(copy.deepcopy(h_t)) # add it to the strong classifier\\n\\n if self.algorithm == 'adaboost':\\n self.classifiers[-1].update_alpha(weighted_patches)\\n weighted_patches = self._adaboost_reweight(weighted_patches, t)\\n elif self.algorithm == 'wald':\\n kde_n, kde_p, xs_n, xs_p = self._estimate_ratios(training_data, t)\\n # find decision thresholds for the strong classifier\\n self._tune_thresholds(kde_n, kde_p, xs_n, xs_p, t)\\n # throw away training samples that fall in our thresholds\\n weighted_patches = self._reweight_and_discard_irrelevant(weighted_patches, t)\\n # sample new training data\\n training_data = random_sample_weighted_patches(weighted_patches, training_set_size)\\n if len(training_data) == 0:\\n print \\\"no more training data!\\\"\\n break\\n toc = time.clock()\\n print toc - tic\\n print self\",\n \"def probs_for_breeds_h5(breed_predictions):\\n predictions = []\\n for (x), value in np.ndenumerate(breed_predictions[0]):\\n predictions.append([x[0], str(dog_names[x[0]]), value])\\n sorted_predictions = sorted(predictions, key=itemgetter(2), reverse=True)\\n for prediction in sorted_predictions[:5]:\\n print dog_names[prediction[0]] + ': ' + str(prediction[2])\",\n \"def compute_recall(data, num_labels = 4): \\n \\n # Declarating list to store results\\n recalls = []\\n \\n for instance in data:\\n \\n # Declarating list to store individual results\\n instance_recalls = []\\n \\n for i in np.arange(num_labels):\\n \\n # Computing and storing accuracy for each class\\n instance_recalls.append(recall_score(instance[:, 2 + i], instance[:, 2 + i + 4]))\\n \\n # Storing mean results of the instance\\n recalls.append(np.mean(instance_recalls))\\n \\n # Returning mean of all results\\n return np.mean(recalls)\",\n \"def test_200_boosted_goal_difference_for_home_models_with_thresholds(self):\\n\\n def create_model_fn(fn_team: str):\\n team_stat = Stats.n_sample_stats_for_team(cursor=db_in_cursor,\\n team=fn_team,\\n last_sample_date=self.model_date,\\n n_samples=self.num_samples,\\n normalize_by_matches=True)\\n\\n\\n return FeatureModel(\\n input_data=[self.home_boost + team_stat.goal_diff, team_stat.goal_diff],\\n id=team_stat.team_name\\n )\\n\\n\\n for match_date in played_home_OR_away_before_dates:\\n ####\\n # Build model up to the day before the match\\n ####\\n self.home_boost = 0.72\\n self.model_date = match_date - timedelta(days=1)\\n self.num_samples = num_matches_in_season\\n\\n models: {str: FeatureModel} = FeatureModel.create_models_for_all_teams(\\n model_making_fn=create_model_fn, entities=teams)\\n\\n self.persist_models(model_gen_date=self.model_date, model_description=self.shortDescription(), models=models)\\n\\n self.make_and_store_predictions_for_date(match_date=match_date, models=models, draw_range=(0.3, 0.9))\",\n \"def xgboost_cv(self, nsplits: int = 5) -> (float, float, float):\\r\\n x_train, x_test, y_train, y_test = train_test_split(self.x, self.y, test_size=0.2)\\r\\n params = {\\r\\n \\\"max_depth\\\": [2, 3, 5, 8],\\r\\n \\\"eta\\\": [0.01, 0.05, 0.1, 0.15, 0.2],\\r\\n \\\"objective\\\": ['binary:logistic'],\\r\\n \\\"sumsample\\\": [0.5, 0.7, 1],\\r\\n \\\"colsample_bytree\\\": [0.5, 0.7, 1],\\r\\n \\\"n_estimators\\\": [50, 100, 200, 500],\\r\\n }\\r\\n \\\"\\\"\\\"\\r\\n fit_params = {\\r\\n \\\"early_stopping_rounds\\\": 20,\\r\\n \\\"eval_metric\\\": \\\"error\\\",\\r\\n \\\"eval_set\\\": [(x_test, y_test)]\\r\\n }\\r\\n \\\"\\\"\\\"\\r\\n model = xgb.XGBClassifier()\\r\\n gridcv = GridSearchCV(model, params, cv=nsplits)\\r\\n gridcv.fit(x_train, y_train) # , **fit_params)\\r\\n best_params = gridcv.best_params_\\r\\n cv = KFold(n_splits=nsplits)\\r\\n acc_result = []\\r\\n for train, test in cv.split(self.x):\\r\\n x_train = self.x[train, :]\\r\\n x_test = self.x[test, :]\\r\\n y_train = self.y[train]\\r\\n y_test = self.y[test]\\r\\n model = xgb.XGBClassifier(**best_params).fit(x_train, y_train)\\r\\n \\\"\\\"\\\"\\r\\n x_t, x_v, y_t, y_v = train_test_split(x_train, y_train, test_size=0.2)\\r\\n model = xgb.XGBClassifier(**best_params).fit(x_t, y_t, eval_metric=\\\"error\\\", eval_set=[(x_v, y_v)],\\r\\n early_stopping_rounds=20)\\r\\n \\\"\\\"\\\"\\r\\n y_predict = model.predict(x_test)\\r\\n acc_result.append(binary_acc(y_test, y_predict))\\r\\n return np.mean(acc_result), np.std(acc_result), best_params\",\n \"def compute_strategies_given_max_winning_bid(max_winning_bid, bidders):\\r\\n bid_start_points = [[-1.0] * len(bidder.values) for bidder in bidders]\\r\\n bid_end_points = [[-1.0] * len(bidder.values) for bidder in bidders]\\r\\n F_jump_points = [[(max_winning_bid, 1.0)] for _ in range(len(bidders))]\\r\\n\\r\\n # current state\\r\\n is_active = [0] * len(bidders)\\r\\n remaining_prob = [-1.0] * len(bidders)\\r\\n cur_bid = max_winning_bid\\r\\n cur_value_idx = [len(bidder.values) - 1 for bidder in bidders]\\r\\n\\r\\n def cur_value(bidder_idx):\\r\\n if cur_value_idx[bidder_idx] >= 0:\\r\\n return bidders[bidder_idx].values[cur_value_idx[bidder_idx]]\\r\\n else:\\r\\n return None\\r\\n\\r\\n def next_candidate():\\r\\n \\\"\\\"\\\"the next bidder to enter the bidding set\\\"\\\"\\\"\\r\\n candidate_bidder = -1\\r\\n candidate_value = -1\\r\\n for n in range(len(bidders)):\\r\\n if (is_active[n] == 0 and cur_value(n) is not None\\r\\n and cur_value(n) > max(candidate_value, cur_bid)):\\r\\n candidate_value = bidders[n].values[cur_value_idx[n]]\\r\\n candidate_bidder = n\\r\\n return candidate_value, candidate_bidder\\r\\n\\r\\n while True:\\r\\n # compute bidding set\\r\\n max_inactive_value, entering_bidder = next_candidate()\\r\\n while entering_bidder >= 0:\\r\\n active_values = [cur_value(j) for j in range(len(bidders)) if is_active[j] == 1]\\r\\n if ((sum(is_active) < 2 or\\r\\n h(cur_bid, cur_value(entering_bidder), active_values) >= 0) and\\r\\n not max_inactive_value > cur_bid > max_inactive_value - 1e-8):\\r\\n is_active[entering_bidder] = 1\\r\\n bid_start_points[entering_bidder][cur_value_idx[entering_bidder]] = cur_bid\\r\\n remaining_prob[entering_bidder] = bidders[entering_bidder].prob[cur_value_idx[entering_bidder]]\\r\\n max_inactive_value, entering_bidder = next_candidate()\\r\\n else:\\r\\n break\\r\\n\\r\\n # terminates computation\\r\\n if sum(is_active) < 2:\\r\\n for i in range(len(bidders)):\\r\\n if is_active[i] == 1:\\r\\n bid_end_points[i][cur_value_idx[i]] = cur_bid\\r\\n break\\r\\n\\r\\n # compute next change point\\r\\n exiting_criteria = H\\r\\n exp_exiting_criteria = exp_H\\r\\n change_points = [-1e8] * len(bidders)\\r\\n active_values = [cur_value(j) for j in range(len(bidders)) if is_active[j] == 1 and cur_value(j) is not None]\\r\\n for i in range(len(bidders)):\\r\\n if cur_value(i) is None:\\r\\n continue\\r\\n if is_active[i] == 0:\\r\\n try:\\r\\n change_points[i] = optimize.brentq(\\r\\n lambda x: h(x, cur_value(i), active_values, poly_form=True),\\r\\n -1e8,\\r\\n cur_bid)\\r\\n except ValueError:\\r\\n change_points[i] = -1e8\\r\\n else:\\r\\n if sum(bidders[i].prob[:cur_value_idx[i]]) == 0:\\r\\n change_points[i] = -1e8\\r\\n else:\\r\\n try:\\r\\n change_points[i] = optimize.brentq(\\r\\n lambda x: (exiting_criteria(cur_bid, cur_value(i), active_values) -\\r\\n exiting_criteria(x, cur_value(i), active_values) -\\r\\n (np.log(sum(bidders[i].prob[:cur_value_idx[i]]) + remaining_prob[i]) -\\r\\n np.log(sum(bidders[i].prob[:cur_value_idx[i]])))),\\r\\n -1e8,\\r\\n cur_bid)\\r\\n except ValueError:\\r\\n change_points[i] = -1e8\\r\\n\\r\\n # update state\\r\\n next_change = max(change_points)\\r\\n changing_bidder = np.argmax(change_points)\\r\\n for i in range(len(bidders)):\\r\\n if i == changing_bidder:\\r\\n continue\\r\\n if is_active[i] == 1:\\r\\n remaining_prob[i] = ((sum(bidders[i].prob[:cur_value_idx[i]]) + remaining_prob[i]) /\\r\\n exp_exiting_criteria(cur_bid, cur_value(i), active_values) *\\r\\n exp_exiting_criteria(next_change, cur_value(i), active_values) -\\r\\n sum(bidders[i].prob[:cur_value_idx[i]]))\\r\\n if np.abs(remaining_prob[i]) <= 1e-8:\\r\\n F_jump_points[i].append((next_change, sum(bidders[i].prob[:cur_value_idx[i]])))\\r\\n is_active[i] = 0\\r\\n remaining_prob[i] = -1.0\\r\\n bid_end_points[i][cur_value_idx[i]] = next_change\\r\\n cur_value_idx[i] -= 1\\r\\n else:\\r\\n F_jump_points[i].append((next_change, sum(bidders[i].prob[:cur_value_idx[i]]) + remaining_prob[i]))\\r\\n else:\\r\\n F_jump_points[i].append((next_change, sum(bidders[i].prob[:cur_value_idx[i] + 1])))\\r\\n if is_active[changing_bidder] == 0: # entering the bidding set\\r\\n is_active[changing_bidder] = 1\\r\\n remaining_prob[changing_bidder] = bidders[entering_bidder].prob[cur_value_idx[entering_bidder]]\\r\\n bid_start_points[changing_bidder][cur_value_idx[changing_bidder]] = next_change\\r\\n F_jump_points[changing_bidder].append(\\r\\n (next_change, sum(bidders[changing_bidder].prob[:cur_value_idx[changing_bidder] + 1])))\\r\\n else: # exiting the bidding set\\r\\n is_active[changing_bidder] = 0\\r\\n remaining_prob[changing_bidder] = -1.0\\r\\n bid_end_points[changing_bidder][cur_value_idx[changing_bidder]] = next_change\\r\\n cur_value_idx[changing_bidder] -= 1\\r\\n F_jump_points[changing_bidder].append(\\r\\n (next_change, sum(bidders[changing_bidder].prob[:cur_value_idx[changing_bidder] + 1])))\\r\\n cur_bid = next_change\\r\\n if cur_bid <= 0.0:\\r\\n break\\r\\n solution_state = State(is_active=is_active,\\r\\n remaining_prob=remaining_prob,\\r\\n cur_bid=cur_bid,\\r\\n cur_value_idx=cur_value_idx)\\r\\n\\r\\n return bid_start_points, bid_end_points, F_jump_points, solution_state\",\n \"def classify():\\n yes_dataset = df[df[\\\"_class\\\"] == 1] # 470588\\n no_dataset = df[df[\\\"_class\\\"] == 0] # 1971\\n\\n parameter_analysis = list()\\n for criterion in np.arange(0.05, 0.91, 0.05):\\n print(\\\"doing experiment at criterion = %s ...\\\" % criterion)\\n rate_list = list()\\n for i in range(10):\\n # shuffle yes_dataset and no_dataset, so we can randomly choose 90% yes_dataset\\n # + 90% no_dataset as train dataset, 10% yes_dataset + 10% no_dataset as test dataset\\n yes_index = yes_dataset.index.tolist()\\n random.shuffle(yes_index)\\n no_index = no_dataset.index.tolist()\\n random.shuffle(no_index)\\n \\n # concatenate 90%yes + 90%no, 10%yes + 10%no\\n train = pd.concat([\\n yes_dataset.loc[yes_index[:1774], :],\\n no_dataset.loc[no_index[:423530], :]\\n ])\\n test = pd.concat([\\n yes_dataset.loc[yes_index[1774:], :],\\n no_dataset.loc[no_index[423530:], :]\\n ]) \\n \\n # split data and label\\n train_data, train_label = (train[[\\\"Revenue.Code\\\", \\n \\\"Service.Code\\\", \\n \\\"Procedure.Code\\\", \\n \\\"Diagnosis.Code\\\", \\n \\\"Subscriber.Index\\\"]], \\n train[\\\"_class\\\"])\\n test_data, test_label = (test[[\\\"Revenue.Code\\\", \\n \\\"Service.Code\\\", \\n \\\"Procedure.Code\\\", \\n \\\"Diagnosis.Code\\\", \\n \\\"Subscriber.Index\\\"]], \\n test[\\\"_class\\\"])\\n \\n # apply classifier\\n clf = GaussianNB()\\n clf.fit(train_data, train_label)\\n probability = clf.predict_proba(test_data).T[1]\\n \\n result = pd.DataFrame()\\n result[\\\"_class\\\"] = test_label\\n result[\\\"_predict\\\"] = probability >= criterion\\n \\n result_yes = result[result[\\\"_class\\\"] == 1]\\n yes_yes_rate = sum(result_yes[\\\"_class\\\"] == result_yes[\\\"_predict\\\"])/len(result_yes[\\\"_predict\\\"])\\n \\n result_no = result[result[\\\"_class\\\"] == 0]\\n no_no_rate = sum(result_no[\\\"_class\\\"] == result_no[\\\"_predict\\\"])/len(result_no[\\\"_predict\\\"])\\n \\n rate_list.append((yes_yes_rate, no_no_rate))\\n\\n rate_list = pd.DataFrame(rate_list)\\n yes_yes_rate, no_no_rate = rate_list.mean()[0], rate_list.mean()[1]\\n parameter_analysis.append((criterion, yes_yes_rate, no_no_rate))\\n \\n # save data to excel spreadsheet\\n parameter_analysis = pd.DataFrame(parameter_analysis, columns=[\\\"criterion\\\", \\\"yes_yes_rate\\\", \\\"no_no_rate\\\"])\\n writer = pd.ExcelWriter(\\\"parameter_analysis.xlsx\\\")\\n parameter_analysis.to_excel(writer, \\\"parameter_analysis\\\", index=False)\\n writer.save()\",\n \"def ensemble(scores):\\r\\n c = Counter ()\\r\\n for probs in zip (scores):\\r\\n idx = int (np.argmax (np.array (probs)))\\r\\n c.update ([idx])\\r\\n best = c.most_common (1)[0][0]\\r\\n return best\",\n \"def run_classifier_bayes_statistics(mode, image_type, indices, percentage, smoothing, debug):\\n start = time.time()\\n dat = train_naive_bayes(image_type, smoothing, percentage)\\n end = time.time()\\n output = classify_naive_bayes(dat, mode, indices, debug)\\n return {'accuracy': check_correctness_statistics(output, mode, image_type), 'runtime': (end-start)}\",\n \"def tuneRandomForest(train_set):\\n\\n auc_score = make_scorer(roc_auc_score)\\n acc = make_scorer(accuracy_score)\\n\\n train_set = pd.read_csv(train_set, sep=\\\"\\\\t\\\", low_memory=False)\\n\\n train_output = train_set[\\\"output\\\"].values\\n train_features = train_set[train_set.columns.drop([\\\"labels\\\", \\\"output\\\"])].values\\n\\n #X_train, X_test, y_train, y_test = train_test_split(train_features, train_output, test_size=0.20)\\n\\n # define parameters to be optimized\\n parameters = {\\n 'n_estimators': [int(x) for x in range(200, 3000, 300)],\\n 'max_features': ['log2', 'sqrt', \\\"auto\\\"],\\n 'criterion': [\\\"gini\\\", \\\"entropy\\\"],\\n }\\n #plotGrid(parameters, script_path + \\\"/results/GridSearchPlot.png\\\")\\n\\n scores = ['precision', 'recall', 'f1', auc_score, acc] # compute efficiency based on scores\\n for score in scores:\\n print(\\\"# Tuning hyper-parameters for %s\\\" % score)\\n\\n tune_search = GridSearchCV(\\n RandomForestClassifier(n_jobs=-1),\\n parameters,\\n scoring=score\\n )\\n #tune_search.fit(X_train, y_train)\\n tune_search.fit(train_features, train_output)\\n print(tune_search.best_params_)\\n\\n means = tune_search.cv_results_['mean_test_score']\\n stds = tune_search.cv_results_['std_test_score']\\n for mean, std, params in zip(means, stds, tune_search.cv_results_['params']):\\n print(\\\"%0.3f (+/-%0.03f) for %r\\\" % (mean, std * 2, params))\\n\\n #y_true, y_pred = y_test, tune_search.predict(X_test)\\n # print(classification_report(y_true, y_pred))\\n #print()\",\n \"def postprocess(scores, classes, bboxes, iou_threshold=0.3, score_threshold=0.5):\\n n = len(scores)\\n \\n det_num = 0\\n det_classes = [] \\n det_scores = []\\n det_bboxes = []\\n\\n idx = np.argsort(scores)[::-1]\\n sorted_scores = scores[idx]\\n sorted_bboxes = bboxes[idx]\\n sorted_classes = classes[idx]\\n\\n top_k_ids = []\\n i = 0\\n\\n while i < n:\\n if sorted_scores[i] < score_threshold:\\n break\\n\\n top_k_ids.append(i)\\n det_num += 1\\n det_scores.append(sorted_scores[i])\\n det_bboxes.append(sorted_bboxes[i])\\n det_classes.append(sorted_classes[i])\\n i += 1\\n\\n while i < n:\\n tiled_bbox_i = np.tile(sorted_bboxes[i], (det_num, 1)) \\n flags = (sorted_classes[top_k_ids]==sorted_classes[i])*1.0 \\n ious, iofs, ioss = iou_bbox(tiled_bbox_i, sorted_bboxes[top_k_ids]) \\n max_iou = np.max(ious) \\n # max_iof = np.max(iofs*flags) \\n # max_ios = np.max(ioss*flags) \\n # temp = np.max((max_iof, max_ios))\\n if max_iou > iou_threshold:\\n i += 1\\n else:\\n break\\n\\n return det_num, np.array(det_scores, np.float32), np.array(det_classes, np.int32), np.array(det_bboxes, np.int32)\",\n \"def _train_clf_opt(self, predictions):\\n\\n X = self._construct_clf_opt_X(predictions)\\n y = predictions['ytruth']\\n X, y = self._check_train_labels(X, y)\\n\\n # self.clf_opt.n_estimators += 10 # This was for warm-start\\n self.clf_opt.fit(X, y)\\n self.clf_opt_trained = True\\n\\n if self.aim is not None:\\n ypred = self._predict_proba(self.clf_opt, X=X)\\n ybl = self.bl_predict(n_samples=len(X))\\n x = minimize(self._opt_round_cutoff,\\n np.array([self.round_cutoff if self.round_cutoff is not None else 0.5]),\\n (y, ypred, ybl),\\n method='cobyla',\\n options={'rhobeg': 0.1}).x[0]\\n self.round_cutoff_history.append(x)\\n self.round_cutoff = np.median(self.round_cutoff_history)\\n print('Optimal [%s] round_cutoff=%.4f' % (self.aim, self.round_cutoff))\\n\\n return\",\n \"def compute_splits(feature_df, target_col, max_num_splits):\\n tree_estimator = DecisionTreeClassifier(max_leaf_nodes=max_num_splits+1,\\n class_weight='balanced',\\n random_state=1407)\\n\\n tree_estimator.fit(feature_df, target_col)\\n thresholds = tree_estimator.tree_.threshold[tree_estimator.tree_.children_left != _tree.TREE_LEAF]\\n return sorted(thresholds)\",\n \"def build_classifiers(self):\\n classifiers = []\\n for index, view in enumerate(BayesianKneighborClassifier.views):\\n knn = KNeighborsClassifier(n_neighbors=BayesianKneighborClassifier.best_neighbours[index])\\n BayesianKneighborClassifier.update_current_data(self, index)\\n X_train, X_test, y_train, y_test = BayesianKneighborClassifier.split_test_and_train_data\\\\\\n (self, test_size=0.3)\\n knn.fit(X_train, y_train)\\n classifiers.append(knn)\\n return classifiers\",\n \"def eval_metrics_for_multiclass(self, predicted_answers):\\n total_correct_in_all = 0\\n total_pred_in_all = len(predicted_answers)\\n # initial a dict for total correct in topK counting.\\n total_correct_in_topK = dict([(i, 0) for i in self.topK_list])\\n total_pred_in_topK = dict([(i, 0) for i in self.topK_list])\\n max_topK = max(self.topK_list)\\n label_pred = []\\n label_true = []\\n label_weights = []\\n digits = 3\\n metrics = {}\\n\\n for e_id, sample in predicted_answers.iteritems():\\n # get all correct ids\\n correct_label_indices = sample['correct_labels']\\n # current case, we only have a majority lable for the correct label\\n label_true.append(correct_label_indices[0])\\n # counting all correct for each sample\\n total_correct_in_all += len(correct_label_indices)\\n # select topK\\n sorted_probs_max_topK = sorted(sample['pred_probs'], reverse=True, key=lambda x: x['prob'])[:max_topK]\\n top1_pred = sorted_probs_max_topK[0]\\n label_pred.append(top1_pred['label_index'])\\n\\n # for all topK predictions\\n for i in range(len(sorted_probs_max_topK)):\\n pred = sorted_probs_max_topK[i]\\n for topK in self.topK_list:\\n if i >= topK:\\n continue\\n else:\\n total_pred_in_topK[topK] += 1\\n if pred['label_index'] in correct_label_indices:\\n total_correct_in_topK[topK] += 1\\n\\n if total_correct_in_all != 0:\\n # recall@K\\n recall_at_K = dict([(k, total_correct_in_topK[k] / (total_correct_in_all * 1.0)) for k in self.topK_list])\\n # assign recall@K into metrics\\n for k, v in recall_at_K.items():\\n # Jie\\n # 1 means the greater the better.\\n # -1 means the smaller the better.\\n metrics['R@{}'.format(k)] = (1, v)\\n\\n self.logger.info('total_correct_in_all = {}, correct_in_topK = {}, recall@K = {}'.format(total_correct_in_all, sorted(total_correct_in_topK.items()), sorted(recall_at_K.items())))\\n # here return all the p,r,f for each label, then we compute the micro average later.\\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\\n total_s = np.sum(s)\\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\\n target_names = self.classes\\n name_width = max(len(cn) for cn in target_names)\\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\\n\\n headers = [\\\"precision\\\", \\\"recall\\\", \\\"f1-score\\\", \\\"support\\\"]\\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\\n report = head_fmt.format(u'', *headers, width=width)\\n report += u'\\\\n\\\\n'\\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\\\n'\\n rows = zip(target_names, p, r, f1, s)\\n for row in rows:\\n label_weights.append(row[4])\\n report += row_fmt.format(*row, width=width, digits=digits)\\n metrics['P_{}'.format(row[0])] = (1, row[1])\\n metrics['R_{}'.format(row[0])] = (1, row[2])\\n metrics['F1_{}'.format(row[0])] = (1, row[3])\\n report += u'\\\\n'\\n\\n # compute macro averages\\n p_macro = np.average(p, weights = None)\\n r_macro = np.average(r, weights = None)\\n f1_macro = np.average(f1, weights = None)\\n metrics['P_{}'.format(\\\"macro\\\")] = (1, p_macro)\\n metrics['R_{}'.format(\\\"macro\\\")] = (1, r_macro)\\n metrics['F1_{}'.format(\\\"macro\\\")] = (1, f1_macro)\\n report += row_fmt.format(last_lines_heading[0],\\n p_macro,\\n r_macro,\\n f1_macro,\\n total_s,\\n width=width, digits=digits)\\n\\n # compute weighted macro average\\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\\n p_weighted_average = np.average(p, weights = label_weights)\\n r_weighted_average = np.average(r, weights = label_weights)\\n f1_weighted_average = np.average(f1, weights = label_weights)\\n metrics['P_{}'.format(\\\"weighted_macro\\\")] = (1, p_weighted_average)\\n metrics['R_{}'.format(\\\"weighted_macro\\\")] = (1, r_weighted_average)\\n metrics['F1_{}'.format(\\\"weighted_macro\\\")] = (1, f1_weighted_average)\\n report += row_fmt.format(last_lines_heading[1],\\n p_weighted_average,\\n r_weighted_average,\\n f1_weighted_average,\\n total_s,\\n width=width, digits=digits)\\n # micro average\\n metrics['P_{}'.format(\\\"micro\\\")] = (1, p_micro)\\n metrics['R_{}'.format(\\\"micro\\\")] = (1, r_micro)\\n metrics['F1_{}'.format(\\\"micro\\\")] = (1, f1_micro)\\n report += row_fmt.format(last_lines_heading[2],\\n p_micro,\\n r_micro,\\n f1_micro,\\n total_s,\\n width=width, digits=digits)\\n\\n self.logger.info(\\\"P,R,F1 report as follows:\\\\n {}\\\".format(report))\\n # only plot it at dev and test time, not during training.\\n if self.gen_confusing_matrix:\\n\\n self.logger.info(\\\"Generate confusing matrix photo.\\\")\\n # Compute confusion matrix\\n conf_matrix = confusion_matrix(label_true, label_pred)\\n np.set_printoptions(precision=2)\\n\\n # Plot non-normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d',\\n title='Confusion matrix, without normalization')\\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\\n plt.savefig(wo_norm_fig_path)\\n\\n # Plot normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d', normalize=True,\\n title='Normalized confusion matrix')\\n\\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\\n plt.savefig(norm_fig_path)\\n\\n else:\\n self.logger.warn('invalid total_correct_in_all')\\n\\n return metrics\",\n \"def balance_dataset_weighting(instances):\\n factors = get_balancing_weight_factors(instances)\\n new_instances = [ (features, classification, w * factors[classification]) \\n for features, classification, w in instances ]\\n return new_instances\",\n \"def get_score(data, labels, fold_pairs, name, model, param, numTopVars,\\r\\n rank_per_fold=None, parallel=True, rand_iter=-1):\\r\\n assert isinstance(name, str)\\r\\n logging.info(\\\"Classifying %s\\\" % name)\\r\\n ksplit = len(fold_pairs)\\r\\n# if name not in NAMES:\\r\\n# raise ValueError(\\\"Classifier %s not supported. \\\"\\r\\n# \\\"Did you enter it properly?\\\" % name)\\r\\n\\r\\n # Redefine the parameters to be used for RBF SVM (dependent on\\r\\n # training data)\\r\\n if \\\"SGD\\\" in name:\\r\\n param[\\\"n_iter\\\"] = [25] # [np.ceil(10**3 / len(fold_pairs[0][0]))]\\r\\n classifier = get_classifier(name, model, param, rand_iter=rand_iter)\\r\\n \\r\\n if name == \\\"RBF SVM\\\": #This doesn't use labels, but looks as ALL data\\r\\n logging.info(\\\"RBF SVM requires some preprocessing.\\\"\\r\\n \\\"This may take a while\\\")\\r\\n #\\r\\n is_data_computed_gamma = True\\r\\n #\\r\\n if not is_data_computed_gamma:\\r\\n # Sahil commented the code below that computes the gamma choices from data.\\r\\n # The computed gamma choices seem too low thereby making SVM very slow. Instead, trying out fixed values.\\r\\n print param\\r\\n gamma = param['gamma']\\r\\n gamma = np.array(gamma)\\r\\n print 'gamma', gamma\\r\\n else:\\r\\n #Euclidean distances between samples\\r\\n # sahil switched from the first call to second one for computing the dist as the first one is giving error.\\r\\n # dist = pdist(StandardScaler().fit(data), \\\"euclidean\\\").ravel()\\r\\n dist = pdist(RobustScaler().fit_transform(data), \\\"euclidean\\\").ravel()\\r\\n print 'dist', dist\\r\\n #Estimates for sigma (10th, 50th and 90th percentile)\\r\\n sigest = np.asarray(np.percentile(dist, [10, 50, 90]))\\r\\n print 'sigest', sigest\\r\\n #Estimates for gamma (= -1/(2*sigma^2))\\r\\n gamma = 1./(2*sigest**2)\\r\\n print 'gamma', gamma\\r\\n #\\r\\n #\\r\\n #Set SVM parameters with these values\\r\\n # sahil changed the code a bit to remove a bug\\r\\n # param = [{\\\"kernel\\\": [\\\"rbf\\\"],\\r\\n # \\\"gamma\\\": gamma.tolist(),\\r\\n # \\\"C\\\": np.logspace(-2,2,5).tolist()}]\\r\\n param = {\\\"kernel\\\": [\\\"rbf\\\"],\\r\\n \\\"gamma\\\": gamma.tolist(),\\r\\n \\\"C\\\": np.logspace(-2, 2, 5).tolist()}\\r\\n # if name not in [\\\"Decision Tree\\\", \\\"Naive Bayes\\\"]:\\r\\n if param:\\r\\n if hasattr(classifier,'param_grid'): \\r\\n # isinstance(classifier, GridSearchCV):\\r\\n print 'param', param\\r\\n N_p = np.prod([len(l) for l in param.values()])\\r\\n elif isinstance(classifier, RandomizedSearchCV):\\r\\n N_p = classifier.n_iter\\r\\n else:\\r\\n N_p = 1\\r\\n# is_cv = isinstance(classifier, GridSearchCV) or \\\\\\r\\n# isinstance(classifier, RandomizedSearchCV)\\r\\n# print('Name: {}, ksplit: {}, N_p: {}'.format(name, ksplit, N_p))\\r\\n if (not parallel) or ksplit <= N_p or \\\\\\r\\n (name == \\\"Random Forest\\\") or (\\\"SGD\\\" in name):\\r\\n logging.info(\\\"Attempting to use grid search...\\\")\\r\\n classifier.n_jobs = PROCESSORS\\r\\n classifier.pre_dispatch = 1 # np.floor(PROCESSORS/24)\\r\\n allConfMats = []\\r\\n allTotalErrs = []\\r\\n allFittedClassifiers = []\\r\\n for i, fold_pair in enumerate(fold_pairs):\\r\\n confMats = []\\r\\n totalErrs = []\\r\\n fitted_classifiers = []\\r\\n logging.info(\\\"Classifying a %s the %d-th out of %d folds...\\\"\\r\\n % (name, i+1, len(fold_pairs)))\\r\\n if rank_per_fold is not None:\\r\\n rankedVars = rank_per_fold[i]\\r\\n else:\\r\\n rankedVars = np.arange(data.shape[1])\\r\\n #\\r\\n for numVars in numTopVars:\\r\\n logging.info('Classifying for top %i variables' % numVars)\\r\\n #\\r\\n # print 'rankedVars', rankedVars\\r\\n #\\r\\n confMat, totalErr, fitted_classifier = classify(data[:, rankedVars[:numVars]],\\r\\n labels,\\r\\n fold_pair,\\r\\n classifier)\\r\\n confMats.append(confMat)\\r\\n totalErrs.append(totalErr)\\r\\n fitted_classifiers.append(fitted_classifier)\\r\\n # recheck the structure of area and fScore variables\\r\\n allConfMats.append(confMats)\\r\\n allTotalErrs.append(totalErrs)\\r\\n allFittedClassifiers.append(fitted_classifiers)\\r\\n else:\\r\\n print 'parallel computing going on (debug Sahil ...) ..........................'\\r\\n #\\r\\n classifier.n_jobs = PROCESSORS\\r\\n logging.info(\\\"Multiprocessing folds for classifier {}.\\\".format(name))\\r\\n pool = Pool(processes=min(ksplit, PROCESSORS))\\r\\n out_list = pool.map(per_split_classifier(data, labels, classifier,\\r\\n numTopVars),\\r\\n zip(rank_per_fold, fold_pairs))\\r\\n pool.close()\\r\\n pool.join()\\r\\n #allConfMats = [el[0] for el in out_list]\\r\\n #allTotalErrs = [el[1] for el in out_list]\\r\\n #allFittedClassifiers = [el[2] for el in out_list]\\r\\n allConfMats, allTotalErrs, allFittedClassifiers = tuple(zip(*out_list))\\r\\n return classifier, allConfMats, allTotalErrs, allFittedClassifiers\",\n \"def evaluate(self, Estimator, params):\\n assert hasattr(Estimator, 'fit'),\\\\\\n \\\"Estimator must implement the fit method\\\"\\n assert hasattr(Estimator, 'predict'),\\\\\\n \\\"Estimator must implement the predict method\\\"\\n # Initialize Estimators\\n models = [Estimator(param) for param in params]\\n ac = list()\\n for idx, (search, hold_out) in enumerate(self.cv):\\n if idx >= self.max_outer:\\n break\\n cv = StratifiedKFold(y=self.b[search], n_folds=self.k_folds-1)\\n for jdx, (train, test) in enumerate(cv):\\n if jdx >= self.max_inner:\\n break\\n scores = [self._score(model, train, test) for model in models]\\n ac.append(self._score(models[np.argmax(scores)], search, hold_out))\\n return np.mean(ac)\",\n \"def evaluate_prediction_BoW(vectorizer, classifier, test_data):\\n \\n data = (test_data[k][0] for k in range(len(test_data))) # generator for the train data\\n data_features = vectorizer.transform(data)\\n predictions = classifier.predict(data_features)\\n target = [test_data[k][1] for k in range(len(test_data))]\\n \\n return accuracy_score(target, predictions)\",\n \"def run(self):\\n if self.pb.xvalEN and not self.isXvalMain:\\n dt = np.ones(self.pb.total_exam_no,\\n dtype=\\\"float32\\\") / self.train_exam_no\\n dt[self.val_indices] = 0.0\\n else:\\n dt = np.ones(self.pb.total_exam_no,\\n dtype=\\\"float32\\\") / self.pb.total_exam_no\\n\\n val = np.zeros(8,dtype=\\\"float32\\\")-1\\n boosting = None\\n wl = None\\n if self.pb.algorithm == 'conf-rated':\\n boosting = ConfidenceRated(self)\\n wl = ConfidenceRatedWL(self)\\n elif self.pb.algorithm == 'adaboost':\\n boosting = AdaBoost(self)\\n wl = AdaBoostWL(self)\\n elif self.pb.algorithm == 'adaboost-fast':\\n boosting = AdaBoostFast(self)\\n wl = AdaBoostFastWL(self)\\n elif self.pb.algorithm == 'rankboost':\\n boosting = RankBoost(self)\\n wl = ConfidenceRatedWL(self)\\n elif self.pb.algorithm == 'rankboost-fast':\\n boosting = RankBoost(self)\\n wl = AdaBoostFastWL(self)\\n else:\\n raise Exception(\\\"Unknown Boosting Algorithm\\\")\\n \\n for r in range(self.pb.rounds):\\n tree = wl.run(dt)\\n dt = boosting.run(dt = dt,\\n r = r,\\n tree = tree)\\n \\n if self.isXvalMain:\\n boosting.finalize()\\n \\n \\\"\\\"\\\"Sync the predictions and save them to a file\\\"\\\"\\\"\\n if self.pb.isLeader:\\n if self.pb.xvalEN and not self.isXvalMain:\\n val_predictions = boosting.get_val_predictions()\\n hypotheses = boosting.get_hypotheses()\\n np.savez(self.out_fp,\\n val_predictions = val_predictions,\\n hypotheses = hypotheses,\\n )\\n if self.pb.testEN and self.isXvalMain:\\n train_predictions = boosting.get_train_predictions()\\n test_predictions = boosting.get_test_predictions()\\n hypotheses = boosting.get_hypotheses()\\n np.savez(self.out_fp,\\n train_predictions = train_predictions,\\n test_predictions = test_predictions,\\n hypotheses = hypotheses,\\n )\\n if not self.pb.testEN and self.isXvalMain:\\n train_predictions = boosting.get_train_predictions()\\n hypotheses = boosting.get_hypotheses()\\n np.savez(self.out_fp,\\n train_predictions = train_predictions,\\n hypotheses = hypotheses,\\n )\",\n \"def _do_grid_search_round(self) -> Dict[str, Dict[str, Any]]:\\n\\n cfg = self.cfg_\\n\\n # Get the data to use, vectorizing the sample feature dictionaries\\n y_train = list(self._generate_samples(self.grid_search_ids_, 'y'))\\n X_train = self._vectorize_and_sparsify_data(self.gs_vec_,\\n self.grid_search_ids_)\\n\\n # Feature selection\\n if cfg.feature_selection_percentile != 1.0:\\n loginfo('Removing {0}% of the features during grid search round...'\\n .format(100 - 100*cfg.feature_selection_percentile))\\n X_train = \\\\\\n (SelectPercentile(chi2,\\n percentile=100*cfg.feature_selection_percentile)\\n .fit_transform(X_train, y_train))\\n\\n # Make a `StratifiedKFold` object using the list of labels\\n # NOTE: This will effectively redistribute the samples in the\\n # various grid search folds, but it will maintain the\\n # distribution of labels. Furthermore, due to the use of the\\n # `RandomState` object, it should always happen in the exact\\n # same way.\\n prng = np.random.RandomState(12345)\\n gs_cv_folds_ = StratifiedKFold(y=y_train,\\n n_folds=self.data_.grid_search_folds,\\n shuffle=True,\\n random_state=prng)\\n\\n # Iterate over the learners/parameter grids, executing the grid search\\n # cross-validation for each\\n loginfo('Doing a grid search cross-validation round with {0} folds for'\\n ' each learner and each corresponding parameter grid.'\\n .format(self.data_.grid_search_folds))\\n n_jobs_learners = ['Perceptron', 'SGDClassifier',\\n 'PassiveAggressiveClassifier']\\n learner_gs_cv_params_ = {}\\n for learner, learner_name, param_grids in zip(self.learners_,\\n self.learner_names_,\\n cfg.param_grids):\\n\\n loginfo('Grid search cross-validation for {0}...'\\n .format(learner_name))\\n\\n # If the learner is `MiniBatchKMeans`, set the `batch_size`\\n # parameter to the number of training samples\\n if learner_name == 'MiniBatchKMeans':\\n for param_grid in param_grids:\\n param_grid['batch_size'] = [len(y_train)]\\n\\n # If learner is of any of the learner types in\\n # `n_jobs_learners`, add in the `n_jobs` parameter specified\\n # in the config (but only do so if that `n_jobs` value is\\n # greater than 1 since it won't matter because 1 is the\\n # default, anyway)\\n if cfg.n_jobs > 1:\\n if learner_name in n_jobs_learners:\\n for param_grid in param_grids:\\n param_grid['n_jobs'] = [cfg.n_jobs]\\n\\n # Make `GridSearchCV` instance\\n folds_diff = cfg.grid_search_folds - self.data_.grid_search_folds\\n if (self.data_.grid_search_folds < 2\\n or folds_diff/cfg.grid_search_folds > 0.25):\\n msg = ('Either there weren\\\\'t enough folds after collecting '\\n 'data (via `ExperimentalData`) to do the grid search '\\n 'round or the number of folds had to be reduced to such'\\n ' a degree that it would mean a +25\\\\% reduction in the '\\n 'total number of folds used during the grid search '\\n 'round.')\\n logerr(msg)\\n raise ValueError(msg)\\n gs_cv = GridSearchCV(learner(),\\n param_grids,\\n cv=gs_cv_folds_,\\n scoring=self._resolve_objective_function())\\n\\n # Do the grid search cross-validation\\n gs_cv.fit(X_train, y_train)\\n learner_gs_cv_params_[learner_name] = gs_cv.best_params_\\n del gs_cv\\n\\n del X_train\\n del y_train\\n\\n return learner_gs_cv_params_\",\n \"def compute_score_fast(verbose=1):\\n res = []\\n\\n batch = math.ceil(len(train) / LINEAR_ASSIGNMENT_SEGMENT_SIZE)\\n for start in range(0, len(train), batch):\\n end = min(len(train), start + batch)\\n train_batch = train[start:end]\\n\\n features = branch_model.predict_generator(FeatureGen(train_batch, verbose=verbose), max_queue_size=12, workers=6, verbose=0)\\n score = head_model.predict_generator(ScoreGen(features, verbose=verbose), max_queue_size=12, workers=6, verbose=0)\\n score = score_reshape(score, features)\\n\\n res.append(score)\\n\\n return res\",\n \"def train_w_batch_boost(self, out_tag='my_lstm', save=True, auc_threshold=0.01):\\n\\n self.create_train_valid_set()\\n\\n #paramaters that control batch size\\n best_auc = 0.5\\n #current_batch_size = 1024\\n current_batch_size = 64\\n #max_batch_size = 50000\\n max_batch_size = 50000\\n\\n #keep track of epochs for plotting loss vs epoch, and for getting best model\\n epoch_counter = 0 \\n best_epoch = 1 \\n\\n keep_training = True\\n\\n while keep_training:\\n epoch_counter += 1\\n print('beginning training iteration for epoch {}'.format(epoch_counter))\\n self.train_network(epochs=1, batch_size=current_batch_size)\\n\\n self.save_model(epoch_counter, out_tag)\\n val_roc = self.compute_roc(batch_size=current_batch_size, valid_set=True) #FIXME: what is the best BS here? final BS from batch boost... initial BS? current BS??\\n\\n #get average of validation rocs and clear list entries \\n improvement = ((1-best_auc) - (1-val_roc)) / (1-best_auc)\\n\\n #FIXME: if the validation roc does not improve after n bad \\\"epochs\\\", then update the batch size accordingly. Rest bad epochs to zero each time the batch size increases, if it does\\n\\n #do checks to see if batch size needs to change etc\\n if improvement > auc_threshold:\\n print('Improvement in (1-AUC) of {:.4f} percent. Keeping batch size at {}'.format(improvement*100, current_batch_size))\\n best_auc = val_roc\\n best_epoch = epoch_counter\\n elif current_batch_size*4 < max_batch_size:\\n print('Improvement in (1-AUC) of only {:.4f} percent. Increasing batch size to {}'.format(improvement*100, current_batch_size*4))\\n current_batch_size *= 4\\n if val_roc > best_auc: \\n best_auc = val_roc\\n best_epoch = epoch_counter\\n elif current_batch_size < max_batch_size: \\n print('Improvement in (1-AUC) of only {:.4f} percent. Increasing to max batch size of {}'.format(improvement*100, max_batch_size))\\n current_batch_size = max_batch_size\\n if val_roc > best_auc: \\n best_auc = val_roc\\n best_epoch = epoch_counter\\n elif improvement > 0:\\n print('Improvement in (1-AUC) of only {:.4f} percent. Cannot increase batch further'.format(improvement*100))\\n best_auc = val_roc\\n best_epoch = epoch_counter\\n else: \\n print('AUC did not improve and batch size cannot be increased further. Stopping training...')\\n keep_training = False\\n\\n if epoch_counter > self.max_epochs:\\n print('At the maximum number of training epochs ({}). Stopping training...'.format(self.max_epochs))\\n keep_training = False\\n best_epoch = self.max_epochs\\n \\n print 'best epoch was: {}'.format(best_epoch)\\n print 'best validation auc was: {}'.format(best_auc)\\n self.val_roc = best_auc\\n \\n\\n #delete all models that aren't from the best training. Re-load best model for predicting on test set \\n for epoch in range(1,epoch_counter+1):\\n if epoch is not best_epoch:\\n os.system('rm {}/models/{}_model_epoch_{}.hdf5'.format(os.getcwd(), out_tag, epoch))\\n os.system('rm {}/models/{}_model_architecture_epoch_{}.json'.format(os.getcwd(), out_tag, epoch))\\n os.system('mv {0}/models/{1}_model_epoch_{2}.hdf5 {0}/models/{1}_model.hdf5'.format(os.getcwd(), out_tag, best_epoch))\\n os.system('mv {0}/models/{1}_model_architecture_epoch_{2}.json {0}/models/{1}_model_architecture.json'.format(os.getcwd(), out_tag, best_epoch))\\n\\n #reset model state and load in best weights\\n with open('{}/models/{}_model_architecture.json'.format(os.getcwd(), out_tag), 'r') as model_json:\\n best_model_architecture = model_json.read()\\n self.model = keras.models.model_from_json(best_model_architecture)\\n self.model.load_weights('{}/models/{}_model.hdf5'.format(os.getcwd(), out_tag))\\n\\n if not save:\\n os.system('rm {}/models/{}_model_architecture.json'.format(os.getcwd(), out_tag))\\n os.system('rm {}/models/{}_model.hdf5'.format(os.getcwd(), out_tag))\",\n \"def calculate_accuracy(ground_truth_object_list, pred_object_list):\\n\\n ground_truth_list = np.zeros((1,10))\\n pred_list = np.zeros((1,10))\\n \\n for gt_index in range(len(ground_truth_object_list)):\\n \\n intClass_ground_truth = classMappingDict[ground_truth_object_list[gt_index]['name']]\\n ground_truth_list[0][intClass_ground_truth] = ground_truth_list[0][intClass_ground_truth] + 1\\n\\n for pred_index in range(len(pred_object_list)):\\n\\n intClass_pred = classMappingDict[pred_object_list[pred_index]['name']]\\n pred_list[0][intClass_pred] = pred_list[0][intClass_pred] + 1\\n return ground_truth_list, pred_list\",\n \"def find_best_classifier(classifiers, X_t, y_t, X_v, y_v, params, jobs):\\n\\n # Initialize result storage\\n clfs_return = []\\n train_scores = []\\n test_scores = []\\n\\n # Loop through classifiers\\n for classifier in classifiers:\\n # Grid search, calibrate, and test the classifier\\n classifier, train_score, test_score = train_calibrate_predict(\\n classifier, X_t, y_t, X_v, y_v, params[classifier], jobs)\\n\\n # Append the result to storage\\n clfs_return.append(classifier)\\n train_scores.append(train_score)\\n test_scores.append(test_score)\\n\\n # Return storage\\n return clfs_return, train_scores, test_scores\",\n \"def model(**params):\\n N_frb = 0\\n vs = []\\n hs = []\\n cs = []\\n ncands = []\\n\\n for cand in candlist:\\n c_res = calculate_metric_terms(\\n cand, cluster_function=cluster_function, debug=False, plot=False, **params\\n )\\n t, frb_found, h, c, v = c_res\\n vs.append(v)\\n hs.append(h)\\n cs.append(c)\\n ncands.append(t)\\n\\n if frb_found:\\n N_frb += 1\\n\\n vs = np.array(vs)\\n hs = np.array(hs)\\n cs = np.array(cs)\\n c_avg = np.average(cs, axis=0, weights=ncands)\\n h_avg = np.average(hs, axis=0, weights=ncands)\\n v_avg = np.average(vs, axis=0, weights=ncands)\\n recall = N_frb / len(vs)\\n score = v_avg * recall\\n\\n return score\",\n \"def update(self, round, npc, cheat_labels=None):\\n with torch.no_grad():\\n batch_size = 100\\n ANs_num = self.get_ANs_num(round)\\n logger.debug('Going to choose %d samples as anchors' % ANs_num)\\n features = npc.memory\\n logger.debug(\\\"Start to compute each sample's entropy\\\")\\n for start in xrange(0, self.samples_num, batch_size):\\n logger.progress(start, self.samples_num, 'processing %d/%d samples...')\\n end = start + batch_size\\n end = min(end, self.samples_num)\\n preds = F.softmax(npc(features[start:end], None), 1)\\n self.entropy[start:end] = -(preds * preds.log()).sum(1)\\n logger.debug('Compute entropy done, max(%.2f), min(%.2f), mean(%.2f)' % (self.entropy.max(), self.entropy.min(), self.entropy.mean()))\\n self.anchor_indexes = self.entropy.topk(ANs_num, largest=False)[1]\\n self.instance_indexes = torch.ones_like(self.position).scatter_(0, self.anchor_indexes, 0).nonzero().view(-1)\\n anchor_entropy = self.entropy.index_select(0, self.anchor_indexes)\\n instance_entropy = self.entropy.index_select(0, self.instance_indexes)\\n if self.anchor_indexes.size(0) > 0:\\n logger.debug('Entropies of anchor samples: max(%.2f), min(%.2f), mean(%.2f)' % (anchor_entropy.max(), anchor_entropy.min(), anchor_entropy.mean()))\\n if self.instance_indexes.size(0) > 0:\\n logger.debug('Entropies of instance sample: max(%.2f), min(%.2f), mean(%.2f)' % (instance_entropy.max(), instance_entropy.min(), instance_entropy.mean()))\\n logger.debug('Start to get the position of both anchor and instance samples')\\n instance_cnt = 0\\n for i in xrange(self.samples_num):\\n logger.progress(i, self.samples_num, 'processing %d/%d samples...')\\n if (i == self.anchor_indexes).any():\\n self.position[i] = (self.anchor_indexes == i).max(0)[1]\\n continue\\n instance_cnt -= 1\\n self.position[i] = instance_cnt\\n logger.debug('Start to find %d neighbours for each anchor sample' % self.ANs_size)\\n anchor_features = features.index_select(0, self.anchor_indexes)\\n self.neighbours = torch.LongTensor(ANs_num, self.ANs_size)\\n for start in xrange(0, ANs_num, batch_size):\\n logger.progress(start, ANs_num, 'processing %d/%d samples...')\\n end = start + batch_size\\n end = min(end, ANs_num)\\n sims = torch.mm(anchor_features[start:end], features.t())\\n sims.scatter_(1, self.anchor_indexes[start:end].view(-1, 1), -1.0)\\n _, self.neighbours[start:end] = sims.topk(self.ANs_size, largest=True, dim=1)\\n logger.debug('ANs discovery done')\\n if cheat_labels is None:\\n return 0.0\\n logger.debug('Start to compute ANs consistency')\\n anchor_label = cheat_labels.index_select(0, self.anchor_indexes)\\n neighbour_label = cheat_labels.index_select(0, self.neighbours.view(-1)).view_as(self.neighbours)\\n self.consistency = (anchor_label.view(-1, 1) == neighbour_label).float().mean()\\n return self.consistency\",\n \"def test_220_boosted_goal_difference_for_home_models_with_various_upper_home_win_threshold(self):\\n\\n def create_model_fn(fn_team: str):\\n team_stat = Stats.n_sample_stats_for_team(cursor=db_in_cursor,\\n team=fn_team,\\n last_sample_date=self.model_date,\\n n_samples=self.num_samples,\\n normalize_by_matches=True)\\n\\n\\n return FeatureModel(\\n input_data=[self.home_boost + team_stat.goal_diff, team_stat.goal_diff],\\n id=team_stat.team_name\\n )\\n\\n default_threshold_lower = 0.3\\n default_threshold_upper = 0.9\\n\\n explore_range = (default_threshold_lower, 5.0)\\n num_steps_wanted = 60\\n step_size = (explore_range[1] - explore_range[0])/num_steps_wanted\\n\\n threshold_lower = default_threshold_lower\\n for threshold_upper in StatsPredictionPremierLeague.crange(first=explore_range[0], test=lambda x: x <= explore_range[1],\\n update=lambda x: x + step_size):\\n for match_date in played_home_OR_away_before_dates:\\n ####\\n # Build model up to the day before the match\\n ####\\n self.home_boost = 0.72\\n self.model_date = match_date - timedelta(days=1)\\n self.num_samples = num_matches_in_season\\n\\n models: {str: FeatureModel} = FeatureModel.create_models_for_all_teams(\\n model_making_fn=create_model_fn, entities=teams)\\n\\n self.persist_models(model_gen_date=self.model_date, model_description=self.shortDescription(), models=models)\\n\\n # variant_string = 'threshold_lower=%f, threshold_upper=%f' % (threshold_lower, threshold_upper)\\n self.make_and_store_predictions_for_date(match_date=match_date, models=models, draw_range=(threshold_lower, threshold_upper),\\n variants=threshold_upper)\",\n \"def cal_average_kill_turns(deck):\\n #Results array\\n turn_results = np.zeros(NUM_SIMS)\\n \\n #Simulation loop\\n for i in range(NUM_SIMS): \\n if VERBOSE:\\n print('Running simulation ' + str(i + 1)) \\n turn_results[i] = cal_kill_turn(copy.deepcopy(deck))\\n #End of Simulations\\n \\n #DETERMINE ATK\\n average_kill_turn = np.average(turn_results)\\n min_kill_turn = np.min(turn_results)\\n max_kill_turn = np.max(turn_results)\\n \\n return average_kill_turn, min_kill_turn, max_kill_turn\",\n \"def setUpMax(roundX):\\n vals = []\\n for attribute in roundX[\\\"attributes\\\"]:\\n vals.append(roundX[\\\"attributes\\\"][attribute][\\\"gain\\\"])\\n branch = []\\n for attribute in roundX[\\\"attributes\\\"]:\\n if max(vals) == roundX[\\\"attributes\\\"][attribute][\\\"gain\\\"]:\\n branch.append(attribute)\\n return branch\",\n \"def findRFBestDepth():\\n resultList = []\\n BestScore = 0\\n # iterate through different max_depths from 1 to 19\\n for max_depth in range(1,20):\\n rforest = ensemble.RandomForestClassifier(max_depth=max_depth, n_estimators=100)\\n trainng_score = []\\n testing_score = []\\n # run 10 different cross-validation\\n for index in range(10):\\n # split into cross-validation sets.\\n cv_data_train, cv_data_test, cv_target_train, cv_target_test = \\\\\\n cross_validation.train_test_split(X_train, y_train, test_size=0.1)\\n\\n # fit the model using the cross-validation data\\n # and tune parameter, such as max_depth here\\n rforest = rforest.fit(cv_data_train, cv_target_train)\\n trainng_score += [rforest.score(cv_data_train,cv_target_train)]\\n testing_score += [rforest.score(cv_data_test,cv_target_test)]\\n\\n # Compute the average score for both traning and testing data\\n trainng_avgScore = 1.0 * sum(trainng_score)/len(trainng_score)\\n testing_avgScore = 1.0 * sum(testing_score)/len(testing_score)\\n\\n # find the best score\\n if testing_avgScore > BestScore:\\n BestScore = testing_avgScore\\n best_depth = max_depth\\n resultList += [[best_depth, trainng_avgScore, testing_avgScore]]\\n print ('The best average score and the corresponding max_depth is: ')\\n return BestScore, best_depth\",\n \"def get_candidate_objects(output, img_size, classes, anchors, threshold):\\n\\n #threshold = 0.8\\n iou_threshold = 0.4\\n\\n boxes, probs = parse_yolo_output_v2(output, img_size, len(classes), anchors)\\n filter_mat_probs = (probs >= threshold)\\n filter_mat_boxes = np.nonzero(filter_mat_probs)[0:3]\\n boxes_filtered = boxes[filter_mat_boxes]\\n probs_filtered = probs[filter_mat_probs]\\n classes_num_filtered = np.argmax(probs, axis=3)[filter_mat_boxes]\\n\\n idx = np.argsort(probs_filtered)[::-1]\\n boxes_filtered = boxes_filtered[idx]\\n probs_filtered = probs_filtered[idx]\\n classes_num_filtered = classes_num_filtered[idx]\\n\\n # too many detections - exit\\n if len(boxes_filtered) > 1e3:\\n print(\\\"Too many detections, maybe an error? : {}\\\".format(\\n len(boxes_filtered)))\\n return []\\n\\n probs_filtered = non_maxima_suppression(boxes_filtered, probs_filtered,\\n classes_num_filtered, iou_threshold)\\n\\n filter_iou = (probs_filtered > 0.0)\\n boxes_filtered = boxes_filtered[filter_iou]\\n probs_filtered = probs_filtered[filter_iou]\\n classes_num_filtered = classes_num_filtered[filter_iou]\\n\\n result = []\\n for class_id, box, prob in zip(classes_num_filtered, boxes_filtered, probs_filtered):\\n result.append([classes[class_id], box[0], box[1], box[2], box[3], prob])\\n\\n return result\",\n \"def test_071_various_boosted_goal_difference_for_home_models(self):\\n\\n def create_model_fn(fn_team: str):\\n team_stat = Stats.n_sample_stats_for_team(cursor=db_in_cursor,\\n team=fn_team,\\n last_sample_date=self.model_date,\\n n_samples=self.num_samples,\\n normalize_by_matches=True)\\n\\n\\n return FeatureModel(\\n input_data=[self.home_boost + team_stat.goal_diff, team_stat.goal_diff],\\n id=team_stat.team_name\\n )\\n\\n # TODO: convert this to use crange\\n for i in range(0, 201):\\n boost = i/100\\n\\n for match_date in played_home_OR_away_before_dates:\\n ####\\n # Build model up to the day before the match\\n ####\\n self.home_boost = boost\\n self.model_date = match_date - timedelta(days=1)\\n self.num_samples = num_matches_in_season\\n\\n models: {str: FeatureModel} = FeatureModel.create_models_for_all_teams(\\n model_making_fn=create_model_fn, entities=teams)\\n\\n model_desc = 'gdn_boost_%s' % boost\\n self.persist_models(model_gen_date=self.model_date, model_description=model_desc, models=models)\\n\\n self.make_and_store_predictions_for_date(match_date=match_date, models=models, variants=model_desc)\",\n \"def _evaluate_performance__static_winners(self):\\n # | - _evaluate_performance__\\n\\n # | - class attributes #################################################\\n AL = self\\n al_gen = self.al_gen\\n verbose = self.verbose\\n seed_ids = self.seed_ids\\n acquisition_bin = self.acquisition_bin\\n completed_ids = self.completed_ids\\n CandidateSpace = self.CandidateSpace\\n RegressionModel = self.RegressionModel\\n DuplicateFinder = self.DuplicateFinder\\n al_gen_dict = self.al_gen_dict\\n\\n stop_mode = self.stop_mode\\n stop_num_generations = self.stop_num_generations\\n\\n index_acq_gen_dict = self.index_acq_gen_dict\\n #__| #################################################################\\n\\n # #####################################################################\\n mode = \\\"lowest_N\\\" # 'lowest_N' or 'lowest_perc'\\n\\n N_ids = 10\\n lowest_perc = 5\\n\\n # Number of consecutive generations that the Nth best systems must\\n # remain static\\n M_gens = 3\\n # #####################################################################\\n\\n if mode == \\\"lowest_perc\\\":\\n num_candidates = CandidateSpace.FingerPrints.df_pre.shape[0]\\n N_ids = int(num_candidates * (lowest_perc * 0.01))\\n\\n gen_keys = list(AL.al_gen_dict.keys())\\n\\n if len(gen_keys) > M_gens:\\n latest_M_keys = gen_keys[-(M_gens + 1):]\\n last_gen_key = gen_keys[-1]\\n\\n al_gen_dict_subset_i = dict(zip(\\n latest_M_keys,\\n [AL.al_gen_dict.get(i, None) for i in latest_M_keys]))\\n\\n indices_list = []\\n iterator = enumerate(al_gen_dict_subset_i.items())\\n for i_cnt, (gen_i, AL_i) in iterator:\\n model_i = AL_i.model\\n\\n model_i = AL.add_main_Y_to_model(\\n model_i, plot_dft_instead_of_pred=True)\\n model_i = model_i[(model_i[\\\"duplicate\\\"] == False)]\\n model_i = model_i.sort_values(\\\"Y_main\\\")\\n\\n indices_i = model_i.index.tolist()\\n\\n indices_list.append(indices_i)\\n\\n if i_cnt >= M_gens:\\n indices_i = indices_list[i_cnt][0:N_ids]\\n ids_static_list = []\\n for j in range(M_gens):\\n indices_j = indices_list[i_cnt - (j + 1)][0:N_ids]\\n ids_static = indices_j == indices_i\\n ids_static_list.append(ids_static)\\n\\n ids_are_static = all(ids_static_list)\\n\\n self.performance__static_winners[last_gen_key] = ids_are_static\\n #__|\",\n \"def majority_vote():\\n iris = datasets.load_iris()\\n x_vals, y_vals = iris.data[50:, [1, 2]], iris.target[50:]\\n labenc = LabelEncoder()\\n y_vals = labenc.fit_transform(y_vals)\\n x_train, x_test, y_train, y_test = train_test_split(x_vals, y_vals,\\n test_size=0.5, random_state=1)\\n\\n clf1 = LogisticRegression(penalty='l2', C=0.001, random_state=0)\\n clf2 = DecisionTreeClassifier(max_depth=1, criterion='entropy', random_state=0)\\n clf3 = KNeighborsClassifier(n_neighbors=1, p=2, metric='minkowski')\\n pipe1 = Pipeline([['sc', StandardScaler()], ['clf', clf1]])\\n pipe3 = Pipeline([['sc', StandardScaler()], ['clf', clf3]])\\n clf_labels = ['Logistic Regression', 'Decision Tree', 'KNN']\\n\\n # Majority Rule (hard) Voting\\n mv_clf = MajorityVoteClassifier(classifiers=[pipe1, clf2, pipe3])\\n\\n clf_labels += ['Majority Voting']\\n all_clf = [pipe1, clf2, pipe3, mv_clf]\\n print('10-fold cross validation:\\\\n')\\n for clf, label in zip(all_clf, clf_labels):\\n scores = cross_val_score(estimator=clf, X=x_train, y=y_train, cv=10, scoring='roc_auc')\\n print(\\\"ROC AUC: %0.2f (+/- %0.2f) [%s]\\\" % (scores.mean(), scores.std(), label))\\n\\n colors = ['black', 'orange', 'blue', 'green']\\n linestyles = [':', '--', '-.', '-']\\n for clf, label, clr, lin_style in zip(all_clf, clf_labels, colors, linestyles):\\n # assuming the label of the positive class is 1\\n y_pred = clf.fit(x_train, y_train).predict_proba(x_test)[:, 1]\\n fpr, tpr, _ = roc_curve(y_true=y_test, y_score=y_pred)\\n print(y_pred)\\n roc_auc = auc(x=fpr, y=tpr)\\n plt.plot(fpr, tpr, color=clr, linestyle=lin_style,\\n label='%s (auc = %0.2f)' % (label, roc_auc))\\n\\n plt.legend(loc='lower right')\\n plt.plot([0, 1], [0, 1], linestyle='--', color='gray', linewidth=2)\\n\\n plt.xlim([-0.1, 1.1])\\n plt.ylim([-0.1, 1.1])\\n plt.grid()\\n plt.xlabel('False Positive Rate')\\n plt.ylabel('True Positive Rate')\\n plt.tight_layout()\\n plt.savefig(IMG_PATH + 'roc.png', dpi=300)\\n plt.close()\\n\\n stdc = StandardScaler()\\n x_train_std = stdc.fit_transform(x_train)\\n all_clf = [pipe1, clf2, pipe3, mv_clf]\\n x_min = x_train_std[:, 0].min() - 1\\n x_max = x_train_std[:, 0].max() + 1\\n y_min = x_train_std[:, 1].min() - 1\\n y_max = x_train_std[:, 1].max() + 1\\n xxx, yyy = np.meshgrid(np.arange(x_min, x_max, 0.1), np.arange(y_min, y_max, 0.1))\\n _, axarr = plt.subplots(nrows=2, ncols=2, sharex='col', sharey='row', figsize=(7, 5))\\n for idx, clf, ttt in zip(product([0, 1], [0, 1]), all_clf, clf_labels):\\n clf.fit(x_train_std, y_train)\\n z_vals = clf.predict(np.c_[xxx.ravel(), yyy.ravel()])\\n z_vals = z_vals.reshape(xxx.shape)\\n axarr[idx[0], idx[1]].contourf(xxx, yyy, z_vals, alpha=0.3)\\n axarr[idx[0], idx[1]].scatter(x_train_std[y_train == 0, 0], x_train_std[y_train == 0, 1],\\n c='blue', marker='^', s=50)\\n axarr[idx[0], idx[1]].scatter(x_train_std[y_train == 1, 0], x_train_std[y_train == 1, 1],\\n c='red', marker='o', s=50)\\n axarr[idx[0], idx[1]].set_title(ttt)\\n plt.text(-3.5, -4.5, s='Sepal width [standardized]', ha='center', va='center', fontsize=12)\\n plt.text(-10.5, 4.5, s='Petal length [standardized]', ha='center', va='center',\\n fontsize=12, rotation=90)\\n plt.tight_layout()\\n plt.savefig(IMG_PATH + 'voting_panel.png', bbox_inches='tight', dpi=300)\\n # print(mv_clf.get_params())\\n params = {'decisiontreeclassifier__max_depth': [1, 2],\\n 'pipeline-1__clf__C': [0.001, 0.1, 100.0]}\\n grid = GridSearchCV(estimator=mv_clf, param_grid=params, cv=10, scoring='roc_auc')\\n grid.fit(x_train, y_train)\\n\\n for params, mean_score, scores in grid.cv_results_:\\n print(\\\"%0.3f+/-%0.2f %r\\\" % (mean_score, scores.std() / 2, params))\\n print('Best parameters: %s' % grid.best_params_)\\n print('Accuracy: %.2f' % grid.best_score_)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5816989","0.5509983","0.541834","0.53876275","0.53350043","0.5324034","0.5317509","0.5210553","0.51253355","0.51249367","0.5117827","0.50774145","0.50676054","0.5053001","0.5049434","0.50463754","0.50307447","0.5024344","0.50045466","0.4988225","0.49871996","0.49853265","0.496797","0.49630922","0.4962463","0.4962463","0.49445808","0.49445808","0.49346837","0.4915061","0.49147037","0.49029648","0.48947603","0.48902234","0.4880092","0.48785284","0.4872494","0.48663113","0.48621702","0.4836322","0.48341253","0.48313582","0.48304862","0.48124772","0.48106804","0.48093024","0.480035","0.4774042","0.4753646","0.4751876","0.47341278","0.47042534","0.47012588","0.46882576","0.4684615","0.4669601","0.46657744","0.46640527","0.4653915","0.46515006","0.4651438","0.46501628","0.46494442","0.4638865","0.46360883","0.4633391","0.4628563","0.46262583","0.46225294","0.46203148","0.4619837","0.46168995","0.4613162","0.4611607","0.4610725","0.46106502","0.4610073","0.4602581","0.45965496","0.4595106","0.45937976","0.45905387","0.4581257","0.45794016","0.4575004","0.45725113","0.45719722","0.45711634","0.4568506","0.45661357","0.45653266","0.45635393","0.45629495","0.45607963","0.4555738","0.4553366","0.4550541","0.45473","0.45426768","0.45426017"],"string":"[\n \"0.5816989\",\n \"0.5509983\",\n \"0.541834\",\n \"0.53876275\",\n \"0.53350043\",\n \"0.5324034\",\n \"0.5317509\",\n \"0.5210553\",\n \"0.51253355\",\n \"0.51249367\",\n \"0.5117827\",\n \"0.50774145\",\n \"0.50676054\",\n \"0.5053001\",\n \"0.5049434\",\n \"0.50463754\",\n \"0.50307447\",\n \"0.5024344\",\n \"0.50045466\",\n \"0.4988225\",\n \"0.49871996\",\n \"0.49853265\",\n \"0.496797\",\n \"0.49630922\",\n \"0.4962463\",\n \"0.4962463\",\n \"0.49445808\",\n \"0.49445808\",\n \"0.49346837\",\n \"0.4915061\",\n \"0.49147037\",\n \"0.49029648\",\n \"0.48947603\",\n \"0.48902234\",\n \"0.4880092\",\n \"0.48785284\",\n \"0.4872494\",\n \"0.48663113\",\n \"0.48621702\",\n \"0.4836322\",\n \"0.48341253\",\n \"0.48313582\",\n \"0.48304862\",\n \"0.48124772\",\n \"0.48106804\",\n \"0.48093024\",\n \"0.480035\",\n \"0.4774042\",\n \"0.4753646\",\n \"0.4751876\",\n \"0.47341278\",\n \"0.47042534\",\n \"0.47012588\",\n \"0.46882576\",\n \"0.4684615\",\n \"0.4669601\",\n \"0.46657744\",\n \"0.46640527\",\n \"0.4653915\",\n \"0.46515006\",\n \"0.4651438\",\n \"0.46501628\",\n \"0.46494442\",\n \"0.4638865\",\n \"0.46360883\",\n \"0.4633391\",\n \"0.4628563\",\n \"0.46262583\",\n \"0.46225294\",\n \"0.46203148\",\n \"0.4619837\",\n \"0.46168995\",\n \"0.4613162\",\n \"0.4611607\",\n \"0.4610725\",\n \"0.46106502\",\n \"0.4610073\",\n \"0.4602581\",\n \"0.45965496\",\n \"0.4595106\",\n \"0.45937976\",\n \"0.45905387\",\n \"0.4581257\",\n \"0.45794016\",\n \"0.4575004\",\n \"0.45725113\",\n \"0.45719722\",\n \"0.45711634\",\n \"0.4568506\",\n \"0.45661357\",\n \"0.45653266\",\n \"0.45635393\",\n \"0.45629495\",\n \"0.45607963\",\n \"0.4555738\",\n \"0.4553366\",\n \"0.4550541\",\n \"0.45473\",\n \"0.45426768\",\n \"0.45426017\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6702093"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94975,"cells":{"query":{"kind":"string","value":"Create a plane through a given point with given normal and surface material"},"document":{"kind":"string","value":"def __init__(self, point, normal, material):\n self.point = point\n self.norm = unit(normal)\n self.mat = material"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def project_point_plane(point, plane):\n base, normal = plane\n normal = normalize_vector(normal)\n vector = subtract_vectors(point, base)\n snormal = scale_vector(normal, dot_vectors(vector, normal))\n return subtract_vectors(point, snormal)","def plot_plane(unit_normal, x_array, y_array, fore):\n # print'unit normal = ', unit_normal\n z = (((unit_normal[0] * (fore[0] - x_array)) + (unit_normal[1] * (fore[1] - y_array))) / unit_normal[2]) + fore[2]\n # print 'plane numbers\\n', z\n return z","def plane(self):\r\n from lsst.analysis import utils\r\n return utils.fitplane(self.points, self.z)","def mirror_point_to_plane(point, plane):\n assert isinstance(plane, cg3d_plane.CGPlane)\n pn, norm = plane.get_point_and_normal()\n norm.normalize()\n return point - 2.0 * ((point - pn) * norm) * norm","def get_plane_of_points(\n self,\n normal_vector=\"z\",\n planar_coordinate=None,\n ):\n # Get results vectors\n if (normal_vector == \"z\"):\n x_flat = self.floris.grid.x_sorted_inertial_frame[0, 0].flatten()\n y_flat = self.floris.grid.y_sorted_inertial_frame[0, 0].flatten()\n z_flat = self.floris.grid.z_sorted_inertial_frame[0, 0].flatten()\n else:\n x_flat = self.floris.grid.x_sorted[0, 0].flatten()\n y_flat = self.floris.grid.y_sorted[0, 0].flatten()\n z_flat = self.floris.grid.z_sorted[0, 0].flatten()\n u_flat = self.floris.flow_field.u_sorted[0, 0].flatten()\n v_flat = self.floris.flow_field.v_sorted[0, 0].flatten()\n w_flat = self.floris.flow_field.w_sorted[0, 0].flatten()\n\n # Create a df of these\n if normal_vector == \"z\":\n df = pd.DataFrame(\n {\n \"x1\": x_flat,\n \"x2\": y_flat,\n \"x3\": z_flat,\n \"u\": u_flat,\n \"v\": v_flat,\n \"w\": w_flat,\n }\n )\n if normal_vector == \"x\":\n df = pd.DataFrame(\n {\n \"x1\": y_flat,\n \"x2\": z_flat,\n \"x3\": x_flat,\n \"u\": u_flat,\n \"v\": v_flat,\n \"w\": w_flat,\n }\n )\n if normal_vector == \"y\":\n df = pd.DataFrame(\n {\n \"x1\": x_flat,\n \"x2\": z_flat,\n \"x3\": y_flat,\n \"u\": u_flat,\n \"v\": v_flat,\n \"w\": w_flat,\n }\n )\n\n # Subset to plane\n # TODO: Seems sloppy as need more than one plane in the z-direction for GCH\n if planar_coordinate is not None:\n df = df[np.isclose(df.x3, planar_coordinate)] # , atol=0.1, rtol=0.0)]\n\n # Drop duplicates\n # TODO is this still needed now that we setup a grid for just this plane?\n df = df.drop_duplicates()\n\n # Sort values of df to make sure plotting is acceptable\n df = df.sort_values([\"x2\", \"x1\"]).reset_index(drop=True)\n\n return df","def plane(self):\n return plane(self.N, self.o)","def plane_equation(point_a, point_b, point_c):\n v1 = np.subtract(point_a, point_c)\n v2 = np.subtract(point_a, point_b)\n normal = np.cross(v1, v2)\n # print 'b4 norm', normal\n unit_normal = norm_vect(normal)\n # print 'unityyy', unit_normal\n return unit_normal","def get_plane(\n self,\n pos=None,\n norm=None,\n plane=None,\n sx=None,\n sy=None,\n color=\"lightgray\",\n alpha=0.25,\n **kwargs,\n ):\n axes_pairs = dict(sagittal=(0, 1), horizontal=(2, 0), frontal=(2, 1))\n\n if pos is None:\n pos = self.root._mesh.centerOfMass()\n\n try:\n norm = norm or self.space.plane_normals[plane]\n except KeyError: # pragma: no cover\n raise ValueError( # pragma: no cover\n f\"Could not find normals for plane {plane}. Atlas space provides these normals: {self.space.plane_normals}\" # pragma: no cover\n )\n\n # Get plane width and height\n idx_pair = (\n axes_pairs[plane]\n if plane is not None\n else axes_pairs[\"horizontal\"]\n )\n\n bounds = self.root.bounds()\n root_bounds = [\n [bounds[0], bounds[1]],\n [bounds[2], bounds[3]],\n [bounds[4], bounds[5]],\n ]\n\n wh = [float(np.diff(root_bounds[i])) for i in idx_pair]\n if sx is None:\n sx = wh[0]\n if sy is None:\n sy = wh[1]\n\n # return plane\n return Actor(\n Plane(pos=pos, normal=norm, sx=sx, sy=sy, c=color, alpha=alpha),\n name=f\"Plane at {pos} norm: {norm}\",\n br_class=\"plane\",\n )","def plane(self):\n return Plane(Point(0, self.evaluations.exposedWing.edges[2].point1.y, 0), Vector(0, 1, 0),\n hidden=True)","def create_surface_plane(align_to = None, axis = 'x', width = 0.5, freeze_tm = True):\n axis_dict = {'x': (1, 0, 0), 'y': (0, 1, 0), 'z': (0, 0, 1)}\n res = pm.nurbsPlane(\n axis = axis_dict[axis],\n width = width,\n degree = 1,\n constructionHistory = False\n )[0]\n if align_to is not None:\n transformation.align(res, align_to)\n if freeze_tm:\n transformation.freeze_transform(res)\n return res","def __init__(self, normal, position, name=None, reflective=False):\n _Surface.__init__(self, name, reflective)\n self._normal = normalize(normal)\n self._position = np.array(position)","def fit_plane(xyz,z_pos=None):\n mean = np.mean(xyz,axis=0)\n xyz_c = xyz - mean[None,:]\n l,v = np.linalg.eig(xyz_c.T.dot(xyz_c))\n abc = v[:,np.argmin(l)]\n d = -np.sum(abc*mean)\n # unit-norm the plane-normal:\n abcd = np.r_[abc,d]/np.linalg.norm(abc)\n # flip the normal direction:\n if z_pos is not None:\n if np.sum(abcd[:3]*z_pos) < 0.0:\n abcd *= -1\n return abcd","def add_rectangular_plane(center_loc=(0, 0, 0), point_to=(0, 0, 1), size=(2, 2), name=None):\n center_loc = np.array(center_loc)\n point_to = np.array(point_to)\n size = np.append(np.array(size), 0)\n\n bpy.ops.mesh.primitive_plane_add(location=center_loc)\n\n plane_obj = bpy.context.object\n\n if name is not None:\n plane_obj.name = name\n\n plane_obj.dimensions = size\n\n # Point it to target\n direction = Vector(point_to) - plane_obj.location\n # Find quaternion that rotates plane's 'Z' so that it aligns with 'direction'\n # This rotation is not unique because the rotated plane can still rotate about direction vector\n # Specifying 'Y' gives the rotation quaternion with plane's 'Y' pointing up\n rot_quat = direction.to_track_quat('Z', 'Y')\n plane_obj.rotation_euler = rot_quat.to_euler()\n\n # Scene update necessary, as matrix_world is updated lazily\n bpy.context.scene.update()\n\n return plane_obj","def _prepare_plane(self):\n verticies = [\n # main plane - note that the mainplane is scaled so the mat_plane\n # matrix will it transform to the correct coordinates\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i_border[0]/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], self.i_border[1]/self._scaling[1],\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\n\n # coord plane\n 0, 0,\n 0, -self.o_wh[1],\n self.o_wh[0], -self.o_wh[1],\n self.o_wh[0], -self.o_wh[1],\n self.o_wh[0], 0,\n 0, 0,\n\n # axes\n 0, -self.o_wh[1], self.o_wh[0], -self.o_wh[1], #x\n 0, 0, 0, -self.o_wh[1], #y\n ]\n\n colors = [\n 1.0, 1.0, 1.0, 1.0, # outer box XXX Remove outer box...\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n 1.0, 1.0, 1.0, 1.0,\n .9, .9, .9, 9.0, # plot box\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n .9, .9, .9, 9.0,\n 0.0, 0.0, 0.0, 1.0, #lines\n 0.0, 0.0, 0.0, 1.0,\n 0.0, 0.0, 0.0, 1.0,\n 0.0, 0.0, 0.0, 1.0,\n ]\n\n self._fonts = []\n for u in range(1, self._unit_count[0]+1):\n verticies.append(self._unit_w[0]*u)\n verticies.append(-self.o_wh[1]+0.02)\n verticies.append(self._unit_w[0]*u)\n verticies.append(-self.o_wh[1]-0.02)\n colors += [0.0, 0.0, 0.0, 1.0]\n colors += [0.0, 0.0, 0.0, 1.0]\n self._fonts.append([\n '{:.2f}'.format(u*(self.i_axis[0]/self._unit_count[0])-self.i_origin[0]),\n (self._unit_w[0]*u+self.i_border[0]-0.05)*self._scaling[0],\n (-self.o_wh[1]+(self.i_border[3])*0.5)\n ])\n for u in range(0, self._unit_count[1]):\n verticies.append(0.02)\n verticies.append(-self._unit_w[1]*u)\n verticies.append(-0.02)\n verticies.append(-self._unit_w[1]*u)\n colors += [0.0, 0.0, 0.0, 1.0]\n colors += [0.0, 0.0, 0.0, 1.0]\n self._fonts.append([\n '{:.2f}'.format(self.i_axis[1]-u*self.i_axis[1]/self._unit_count[1]-self.i_origin[1]),\n (0.025)*self._scaling[0],\n (-(self._unit_w[1])*u-self.i_border[1]+0.01)*self._scaling[1]\n ])\n\n self._draw_plane_indicies = (0, 12)\n self._draw_line_indicies = (12, 4+self._unit_count[0]*2+self._unit_count[1]*2)\n\n # convert data into valid data format\n verticies = numpy.array(verticies, dtype=numpy.float32)\n colors = numpy.array(colors, dtype=numpy.float32)\n\n self._plane_vao = util.VAO()\n self._plane_vbo = util.VBO(2)\n\n with self._plane_vao:\n # plane verticies\n with self._plane_vbo.get(0):\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(verticies), verticies, GL_STATIC_DRAW)\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_position'), 2, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(0)\n\n # place vertex colors\n with self._plane_vbo.get(1):\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(colors), colors, GL_STATIC_DRAW)\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_color'), 4, GL_FLOAT, GL_FALSE, 0, None)\n glEnableVertexAttribArray(1)","def plane(*args, length: float=0.0, name: AnyStr=\"\", position: List[float, float, float]=None,\n rotation: List[float, float, float]=None, size: float=0.0, width: float=0.0,\n **kwargs)->AnyStr:\n pass","def point_and_plane_pose(plane_point, plane_orientation, points=None, xyz=None):\n vector = plane_orientation\n vector = vector / np.linalg.norm(vector)\n a = vector[0]\n b = vector[1]\n c = vector[2]\n\n d = -a * plane_point[0] - b * plane_point[1] - c * plane_point[2]\n\n if xyz is not None:\n xyz = np.asarray(xyz)\n if points.shape[0] != 3:\n logger.error(\n \"Wrong points shape. [3, N] expected, \" + str(points.shape) + \" given.\"\n )\n elif points is not None:\n points = np.asarray(points)\n if points.shape[1] != 3:\n logger.error(\n \"Wrong points shape. [N, 3] expected, \" + str(points.shape) + \" given.\"\n )\n xyz = points.T\n else:\n logger.error(\"points or xyz must be declared\")\n\n x, y, z = xyz\n z_out = (a * x + b * y + c * z + d) / (a ** 2 + b ** 2 + c ** 2) ** 0.5\n\n return z_out","def _fit_plane_to_point_cloud(\n points_xyz: NDArrayFloat,\n) -> Tuple[float, float, float, float]:\n center_xyz: NDArrayFloat = np.mean(points_xyz, axis=0)\n out: Tuple[NDArrayFloat, NDArrayFloat, NDArrayFloat] = np.linalg.svd(\n points_xyz - center_xyz\n )\n vh = out[2]\n\n # Get the unitary normal vector\n a, b, c = float(vh[2, 0]), float(vh[2, 1]), float(vh[2, 2])\n d: float = -np.dot([a, b, c], center_xyz)\n return (a, b, c, d)","def get_surface_normals_o3d(normals, points, scale=2):\n # total number of points:\n N = points.shape[0]\n\n points = np.vstack(\n (points.to_numpy(), points.to_numpy() + scale * normals)\n )\n lines = [[i, i+N] for i in range(N)]\n colors = np.zeros((N, 3)).tolist()\n\n # build pca line set:\n surface_normals_o3d = o3d.geometry.LineSet(\n points=o3d.utility.Vector3dVector(points),\n lines=o3d.utility.Vector2iVector(lines),\n )\n surface_normals_o3d.colors = o3d.utility.Vector3dVector(colors)\n\n return surface_normals_o3d","def xyz2plane(x,y,z, new_x=[], plane=[], origin=None):\n # preliminary stuff\n if origin != None: x = x - origin\n a,b,c,d = plane\n bottom = np.sqrt(a*a + b*b + c*c) # normalize\n a,b,c,d = a/bottom, b/bottom, c/bottom, d/bottom\n px, py, pz = new_x\n bot = np.sqrt(px*px + py*py + pz*pz) #normalize\n px, py, pz = px/bot, py/bot, pz/bot\n p0 = [px,py,pz]\n # do rotation\n z_hat = [a,b,c]\n y_hat = cross(z_hat, p0)\n x_hat = cross(y_hat, z_hat)\n if type(x)==type(arr) or type(x)==type([]):\n xp, yp, zp = [], [], []\n for i in range(len(x)):\n xp.append(dot([x[i],y[i],z[i]], x_hat))\n yp.append(dot([x[i],y[i],z[i]], y_hat))\n zp.append(dot([x[i],y[i],z[i]], z_hat))\n else:\n xp = dot([x,y,z], x_hat)\n yp = dot([x,y,z], y_hat)\n zp = dot([x,y,z], z_hat)\n return xp, yp, zp","def alpha_surface_reconstruction(pcd, alpha=10):\n road_mesh = o3d.geometry.TriangleMesh.create_from_point_cloud_alpha_shape(pcd, alpha)\n vertices = np.asarray(copy.deepcopy(road_mesh.vertices)) #flatten road mesh\n vertices[:,2] = 0\n flattend_mesh = copy.deepcopy(road_mesh)\n flattend_mesh.vertices = o3d.utility.Vector3dVector(vertices)\n return flattend_mesh, road_mesh","def test_CoordinatePlane(self):\n origin = np.random.randn(3)\n normal = np.random.randn(3)\n up_vector = np.random.randn(3)\n plane = shapes_nd.Plane(origin, normal)\n cplane = shapes_3d.CoordinatePlane(origin, normal, up_vector)\n \n np.testing.assert_almost_equal(cplane.dim, plane.dim)\n np.testing.assert_almost_equal(cplane.origin, plane.origin)\n np.testing.assert_almost_equal(cplane.normal, plane.normal)\n \n p3 = [0, 1, 0]\n c, d = cplane.project_point(p3, ret_dist=True)\n np.testing.assert_almost_equal(p3, cplane.revert_projection(c, d))\n p3 = np.random.randn(5, 3)\n c, d = cplane.project_point(p3, ret_dist=True)\n np.testing.assert_almost_equal(p3, cplane.revert_projection(c, d))","def __init__(self, t, point=None, normal=None, uv=None, material=None):\n self.t = t\n self.point = point\n self.normal = normal\n self.uv = uv\n self.material = material","def addPlaneToScene(self, foot, x, y):\r\n #research\r\n profprint()\r\n scene = slicer.mrmlScene\r\n # Create model node\r\n model = slicer.vtkMRMLModelNode()\r\n model.SetScene(scene)\r\n model.SetName(scene.GenerateUniqueName(\".ObturatorPlane\"))\r\n\r\n planeSource = vtk.vtkPlaneSource()\r\n foot-=25*(x+y)\r\n #planeSource.SetOrigin(np.array(foot))\r\n planeSource.SetOrigin(list(foot))\r\n planeSource.SetPoint1(np.array(foot)+50*x)\r\n planeSource.SetPoint2(np.array(foot)+50*y)\r\n planeSource.Update()\r\n model.SetAndObservePolyData(planeSource.GetOutput())\r\n\r\n # Create display node\r\n modelDisplay = slicer.vtkMRMLModelDisplayNode()\r\n modelDisplay.SetColor(1,1,0) # yellow\r\n modelDisplay.SetBackfaceCulling(0)\r\n modelDisplay.SetScene(scene)\r\n scene.AddNode(modelDisplay)\r\n model.SetAndObserveDisplayNodeID(modelDisplay.GetID())\r\n\r\n # Add to scene\r\n scene.AddNode(model)\r\n # transform = slicer.vtkMRMLLinearTransformNode()\r\n # scene.AddNode(transform)\r\n # model.SetAndObserveTransformNodeID(transform.GetID())\r\n #\r\n # vTransform = vtk.vtkTransform()\r\n # vTransform.Scale(50,50,50)\r\n # #vTransform.RotateX(30)\r\n # transform.SetAndObserveMatrixTransformToParent(vTransform.GetMatrix())\r","def hyperplane(self):\n origin = (self.a+self.b+self.c)/3.\n normal = np.cross(self.a-self.b, self.a-self.c)\n return Hyperplane(origin, normal)","def draw_plane(env, transform, extents=(4,4), texture=None):\n if texture is None:\n texture = np.zeros((100,100,4))\n texture[:,:,1] = 0.2\n texture[:,:,2] = 0.2\n texture[:,:,3] = 0.2\n with env:\n h = env.drawplane(transform, extents=extents, texture=texture)\n return h","def surface(*args, degreeU: int=0, degreeV: int=0, formU: AnyStr=\"\", formV: AnyStr=\"\", knotU:\n Union[float, List[float]]=0.0, knotV: Union[float, List[float]]=0.0, name:\n AnyStr=\"\", objectSpace: bool=True, point: Union[List[float, float, float],\n List[List[float, float, float]]]=None, pointWeight: Union[List[float, float, float,\n float], List[List[float, float, float, float]]]=None, worldSpace: bool=True,\n **kwargs)->AnyStr:\n pass","def SetNormal(self, *args):\n return _itkSurfaceSpatialObjectPointPython.itkSurfaceSpatialObjectPoint3_SetNormal(self, *args)","def SetPlaneMode(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_ConvertSurfaceToBezierBasis_SetPlaneMode(self, *args)","def _update_surface_normals(self):\n\n # This is the case if there are too few points to\n # compute normals so there can be values to remove\n\n #can be important for parallel\n self.swarm.shadow_particles_fetch()\n\n if self.empty:\n self.director.data[...] = 0.0\n else:\n\n particle_coords = self.swarm.particleCoordinates.data\n\n Nx = np.empty(self.swarm.particleLocalCount)\n Ny = np.empty(self.swarm.particleLocalCount)\n Nz = np.empty(self.swarm.particleLocalCount)\n\n for i, xyz in enumerate(particle_coords):\n r, neighbours = self.kdtree.query(particle_coords[i], k=4)\n\n # this point is neighbour[0] and neighbour points are neighbours[(1,2,3)]\n XYZ1 = self.kdtree.data[neighbours[1]]\n XYZ2 = self.kdtree.data[neighbours[2]]\n XYZ3 = self.kdtree.data[neighbours[3]]\n\n dXYZ1 = XYZ2 - XYZ1\n dXYZ2 = XYZ3 - XYZ1\n\n # Cross product of those 2 vectors can be use as the local normal (perhaps)\n\n Nx[i], Ny[i], Nz[i] = np.cross(dXYZ1, dXYZ2)\n #if i == 0:\n # print(Nx, Ny, Nz)\n # print(xyz[0], xyz[1],xyz[2])\n # print((self.insidePt[0] - xyz[0]) * Nx[i] )\n\n if (self.insidePt):\n sign = np.sign( (self.insidePt[0] - xyz[0]) * Nx[i] +\n (self.insidePt[1] - xyz[1]) * Ny[i] +\n (self.insidePt[2] - xyz[2]) * Nz[i] )\n Nx[i] *= sign\n Ny[i] *= sign\n Nz[i] *= sign\n\n\n for i in range(0, self.swarm.particleLocalCount):\n scale = 1.0 / np.sqrt(Nx[i]**2 + Ny[i]**2 + Nz[i]**2)\n Nx[i] *= scale\n Ny[i] *= scale\n Nz[i] *= scale\n\n\n self.director.data[:,0] = Nx[:]\n self.director.data[:,1] = Ny[:]\n self.director.data[:,2] = Nz[:]\n\n print(\"Surf Norms\")\n\n return","def test_create(self):\n f = azplugins.restrain.plane(group=hoomd.group.all(), point=(0,0,0), normal=(1,0,0), k=2.0)\n\n f.set_params(k=5.0)\n f.set_params(k=8)\n\n f.set_params(point=(0,0,1))\n f.set_params(point=[0,0,1])\n f.set_params(point=np.array([0,0,1]))\n\n f.set_params(normal=(0,0,1))\n f.set_params(normal=[0,0,1])\n f.set_params(normal=np.array([0,0,1]))\n\n f.set_params(point=(0,0,0), normal=(1,0,0), k=10.0)","def GetPlane(plane):\r\n pass","def project_onto_plane(vect):\n x, y, z = vect\n \n return (x, y, 0.)","def closest_point_on_plane(point, plane):\n base, normal = plane\n x, y, z = base\n a, b, c = normalize_vector(normal)\n x1, y1, z1 = point\n d = a * x + b * y + c * z\n k = (a * x1 + b * y1 + c * z1 - d) / (a**2 + b**2 + c**2)\n return [x1 - k * a,\n y1 - k * b,\n z1 - k * c]","def fit_plane_to_points(points: np.ndarray, eps: float=1.0e-5):\n # Compute plane origin and subract it from the points array.\n plane_origin = np.mean(points, axis=0)\n x = points - plane_origin\n\n # Dot product to yield a 3x3 array.\n moment = np.dot(x.T, x)\n\n # Extract single values from SVD computation to get normal.\n plane_normal = np.linalg.svd(moment)[0][:,-1]\n small = np.where(np.abs(plane_normal) < eps)\n plane_normal[small] = 0.0\n plane_normal /= np.linalg.norm(plane_normal)\n if (plane_normal[-1] < 0.0):\n plane_normal *= -1.0\n\n return (plane_normal, plane_origin)","def create_plane(self):\n\n # First we calculate our point increment for both the x and y values\n inc_x = (self.xmax - self.xmin)/(self.xlen - 1)\n inc_y = (self.ymax - self.ymin)/(self.ylen - 1)\n\n # This for-loop will add every x-value with every y-value, saving the values column wise\n # i.e. (-10,-10), (-10,-9), (-10.-8),...,(-10,n) for n = our y-values.\n # store these combinations into a list, and add that to our plane. \n # The nested loop will then traverse again and will get the combinations for the next x-value.\n # The loop will continue until all x-values and y-value combinations are added to our plane.\n for y in range(0, self.ylen + 1):\n temp_list = []\n for x in range(0, self.xlen + 1):\n temp_list.append(self.f((self.xmin + x*inc_x) + (self.ymin + y*inc_y)*1j))\n self.plane.append(temp_list)","def invert_point_on_plane(point, plane):\n _, _, proj = project_point_to_plane(point, plane)\n\n u, v = proj[0][1]\n return u, v","def SetNormal(self, *args):\n return _itkSurfaceSpatialObjectPointPython.itkSurfaceSpatialObjectPoint2_SetNormal(self, *args)","def test_point_on_plane(self, point, plane):\n _dist = point.dot(plane[:3]) + plane[3]\n if _dist <= epsilon:\n print('OK => point on plane')\n else:\n print('NO => point not on plane')","def mesh_slicer(self, plane, opt):\n\n # get plane coefficients\n a = plane[0]\n b = plane[1]\n c = plane[2]\n\n # create vtk plane object\n VTKplane = vtk.vtkPlane()\n # for now we choose the center point as the point of rotation\n VTKplane.SetOrigin(self.mesh_poly.GetCenter())\n VTKplane.SetNormal(a, b, c)\n VTKplane.SetOrigin(self.epi_apex_node)\n\n # create cutter\n cutEdges = vtk.vtkCutter()\n cutEdges.SetInputData(self.mesh_poly)\n cutEdges.SetCutFunction(VTKplane)\n cutEdges.GenerateCutScalarsOn()\n cutEdges.SetValue(0, 0.5)\n\n # create renderer\n ren = vtk.vtkRenderer()\n ren.SetBackground(0.0, 0.0, 0.0)\n\n # create mapper\n mapper = vtk.vtkPolyDataMapper()\n mapper.SetInputConnection(cutEdges.GetOutputPort())\n\n # create actor\n actor = vtk.vtkActor()\n actor.SetMapper(mapper)\n actor.GetProperty().SetColor(0.0, 0.0, 1.0)\n actor.GetProperty().SetLineWidth(2)\n\n # display apex point\n apexA = include_points(list(self.epi_apex_node), 1, 15, (0, 0, 1))\n\n if (opt == 'mesh'):\n meshMapper = vtk.vtkPolyDataMapper()\n meshMapper.SetInputData(self.mesh_poly)\n meshActor = vtk.vtkActor()\n meshActor.SetMapper(meshMapper)\n meshActor.GetProperty().SetColor(1.0, 0.0, 0.0)\n\n # generate renderer\n ren.AddActor(self.meshActor)\n ren.AddActor(actor)\n ren.AddActor(apexA)\n\n else:\n ren.AddActor(actor)\n ren.AddActor(apexA)\n\n # display\n vtk_show(ren)","def proj_to_plane(norm, d, pts):\n a = norm[0]\n b = norm[1]\n c = norm[2]\n\n p = []\n\n for i in range(len(pts)):\n x_p = pts[i][0]\n y_p = pts[i][1]\n z_p = pts[i][2]\n\n if a != 0:\n x_0 = (b * b + c * c) * x_p - a * b * y_p - a * c * z_p - a * d\n y_0 = (b * 1.0 / a) * (x_0 - x_p) + y_p\n z_0 = (c * 1.0 / a) * (x_0 - x_p) + z_p\n\n elif b != 0:\n x_0 = x_p \n y_0 = c * c * y_p - b * (d + c)\n z_0 = (c * 1.0 / b) *(y_0 - y_p) + z_p\n\n else:\n x_0 = x_p\n y_0 = y_p\n z_0 = - d * 1.0 / c\n\n p.append([x_0, y_0, z_0])\n \n return p","def proj_to_plane(norm, d, pts):\n a = norm[0]\n b = norm[1]\n c = norm[2]\n\n p = []\n\n for i in range(len(pts)):\n x_p = pts[i][0]\n y_p = pts[i][1]\n z_p = pts[i][2]\n\n if a != 0:\n x_0 = (b * b + c * c) * x_p - a * b * y_p - a * c * z_p - a * d\n y_0 = (b * 1.0 / a) * (x_0 - x_p) + y_p\n z_0 = (c * 1.0 / a) * (x_0 - x_p) + z_p\n\n elif b != 0:\n x_0 = x_p \n y_0 = c * c * y_p - b * (d + c)\n z_0 = (c * 1.0 / b) *(y_0 - y_p) + z_p\n\n else:\n x_0 = x_p\n y_0 = y_p\n z_0 = - d * 1.0 / c\n\n p.append([x_0, y_0, z_0])\n \n return p","def __init__(self, obj, plane):\n self.obj = obj\n self.plane = plane\n self.plane_origin = plane[0]\n self.plane_normal = plane[1]\n self.distance_from_plane = np.dot((self.obj.vectors-self.plane[0]),\n self.plane[1])\n self.slice_points = []\n\n self.calculate_points()\n \n return None","def _generate_random_points_in_plane(nvect, dparam, npts, eps=0.0):\n np.random.seed(12345)\n a, b, c = nvect / np.linalg.norm(nvect)\n x, y = np.random.rand(npts), np.random.rand(npts)\n z = (dparam - a * x - b * y) / c\n if eps > 0:\n z += np.random.normal(loc=0., scale=eps, size=npts)\n return np.column_stack((x, y, z))","def project_onto_plane(self,z):\n U=self.U\n Q=self.Q_p\n #print(((z-Q[-2,:,[2]])/P[-2,:,[2]]).T)\n #print(P[-2])\n return ((z-Q[-2,:,[2]])/U[-2,:,[2]]).T*U[-2]+Q[-2]","def plane_distance(p, plane):\n x, y, z = p\n A, B, C, D = plane\n return A*x + B*y + C*z + D","def surfcut_points(**kwargs):\n npoints = kwargs.get( 'npoints', 240 )\n origin = kwargs.get( 'origin', vec3(0.,0.,0.)) \n normal = kwargs.get( 'normal', (np.pi/2., 0.) ) \n lims0 = kwargs.get( 'lims0', (-50., 50.) ) \n lims1 = kwargs.get( 'lims1', (-50., 50.) ) \n extents = kwargs.get( 'extents', None) \n \n if extents is not None:\n lims0 = (-extents, extents)\n lims1 = (-extents, extents)\n \n # Make the unit vectors that define the plane\n unit = vec3()\n th = normal[0]\n ph = normal[1]\n unit.set_spherical( 1, th, ph) \n orth0 = vec3( -1.*np.sin(ph), np.cos(ph), 0. )\n orth1 = cross(unit,orth0)\n \n t0 = np.linspace( lims0[0], lims0[1], npoints )\n t1 = np.linspace( lims1[0], lims1[1], npoints ) \n \n # Obtain points on which function will be evaluated\n T0,T1 = np.meshgrid(t0,t1)\n X = origin[0] + T0*orth0[0] + T1*orth1[0] \n Y = origin[1] + T0*orth0[1] + T1*orth1[1]\n Z = origin[2] + T0*orth0[2] + T1*orth1[2] \n \n\n # If given an axes it will plot the reference surface to help visusalize\n # the surface cut\n \n # Note that the axes needs to be created with a 3d projection. \n # For example: \n # fig = plt.figure( figsize=(4.,4.) ) \n # gs = matplotlib.gridspec.GridSpec( 1,1 ) \n # ax0 = fig.add_subplot( gs[0,0], projection='3d' ) \n \n ax0 = kwargs.get( 'ax0', None ) \n if ax0 is not None: \n\n # Plot the reference surface\n ax0.plot_surface(X, Y, Z, rstride=8, cstride=8, alpha=0.3, linewidth=0.)\n ax0.set_xlabel('X')\n ax0.set_ylabel('Y')\n ax0.set_zlabel('Z')\n lmin = min([ ax0.get_xlim()[0], ax0.get_ylim()[0], ax0.get_zlim()[0] ] )\n lmax = max([ ax0.get_xlim()[1], ax0.get_ylim()[1], ax0.get_zlim()[1] ] )\n ax0.set_xlim( lmin, lmax )\n ax0.set_ylim( lmin, lmax )\n ax0.set_zlim( lmin, lmax )\n ax0.set_yticklabels([])\n ax0.set_xticklabels([])\n ax0.set_zticklabels([])\n \n # If given an axes and a potential it will plot the surface cut of the \n # potential \n\n ax1 = kwargs.get( 'ax1', None) \n pot = kwargs.get( 'potential', None) \n\n if (ax1 is not None) and (pot is not None):\n # Evaluate function at points and plot\n EVAL = pot.evalpotential(X,Y,Z)\n\n im =ax1.pcolormesh(T0, T1, EVAL, cmap = plt.get_cmap('jet')) \n # cmaps: rainbow, jet\n\n plt.axes( ax1)\n cbar = plt.colorbar(im)\n cbar.set_label(pot.unitlabel, rotation=0 )#self.unitlabel\n \n return T0, T1, X, Y, Z","def get_projection_point(self, point, plane, test=False):\n return point_on_plane_projection(point, plane, test=test)","def rotate_to_xz_plane(self, point):\n if len(point) == 2:\n x, z = point\n else:\n x, y, z = point\n if y != 0.0:\n x = np.sqrt(x**2 + y**2)\n return abs(x), z","def plane_from_multiple_points(pnts: Iterable[Point]) -> Plane:\n n = len(pnts)\n x = [pnt.x for pnt in pnts]\n y = [pnt.y for pnt in pnts]\n z = [pnt.z for pnt in pnts]\n pntc = Point(sum(x)/n, sum(y)/n, sum(z)/n)\n x = [pnt.x-pntc.x for pnt in pnts]\n y = [pnt.y-pntc.y for pnt in pnts]\n z = [pnt.z-pntc.z for pnt in pnts]\n sxx = sum([x[i]**2 for i in range(n)])\n sxy = sum([x[i]*y[i] for i in range(n)])\n sxz = sum([x[i]*z[i] for i in range(n)])\n syy = sum([y[i]**2 for i in range(n)])\n syz = sum([y[i]*z[i] for i in range(n)])\n d = sxx*syy-sxy**2\n a = (syz*sxy-sxz*syy)/d\n b = (sxy*sxz-sxx*syz)/d\n nrm = Vector(a, b, 1.0)\n return Plane(pntc, nrm)","def from_3p(cls, a: Vector, b: Vector, c: Vector) -> 'Plane':\n n = (b - a).cross(c - a).normalize()\n return Plane(n, n.dot(a))","def SetPlaneMode(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_ShapeConvertToBezier_SetPlaneMode(self, *args)","def pointOnSurface(*args, caching: bool=True, constructionHistory: bool=True, nodeState:\n Union[int, bool]=0, normal: bool=True, normalizedNormal: bool=True,\n normalizedTangentU: bool=True, normalizedTangentV: bool=True, parameterU:\n Union[float, bool]=0.0, parameterV: Union[float, bool]=0.0, position:\n bool=True, tangentU: bool=True, tangentV: bool=True, turnOnPercentage:\n bool=False, q=True, query=True, e=True, edit=True,\n **kwargs)->Union[List[float3], Any]:\n pass","def PlaneNormalVector(h, k, l):\r\n vec = np.array([h, k, l])\r\n return vec/np.linalg.norm(vec)","def fit_plane_to_point_cloud(pc: np.ndarray) -> Tuple[Any, Any, Any, Any]:\n center = pc.sum(axis=0) / pc.shape[0]\n u, s, vh = np.linalg.svd(pc - center)\n\n # Get the unitary normal vector\n u_norm = vh[2, :]\n d = -np.dot(u_norm, center)\n a, b, c = u_norm\n return a, b, c, d","def plot_sag_plane(self, P0=None, sag_pl=None):\n if P0 is None: P0 = np.array([0,0,0])\n if sag_pl is None: sag_pl = self.sp\n norm, d = sag_pl[:3], sag_pl[3]\n import matplotlib.pyplot as plt\n from mpl_toolkits.mplot3d import Axes3D\n plt.ion()\n # create x,y\n xypts = 10\n xrng = 300\n yrng = 130\n xrng_mesh = np.linspace(P0[0], P0[0]-xrng, xypts)\n yrng_mesh = np.linspace(P0[1]-yrng/2., P0[1]+yrng, xypts)\n xx, yy = np.meshgrid(xrng_mesh, yrng_mesh)\n # calculate corresponding z\n zz = -1 * (norm[0] * xx + norm[1] * yy + d) / norm[2]\n # plot the surface\n self.fig = plt.figure()\n self.fig_ax = self.fig.add_subplot(111, projection='3d')\n self.fig_ax.plot_wireframe(xx, yy, zz, color='gray')\n #ax.quiver(P0[0], P0[1], norm[0], norm[1])\n self.fig_ax.set_xlabel('X')\n self.fig_ax.set_ylabel('Y')\n self.fig_ax.set_zlabel('Z')\n self.fig_ax.set_zlim(P0[2]-xrng, P0[2]+yrng)\n plt.show()","def project_point(self, point: array_like) -> Point:\n # Vector from the point in space to the point on the plane.\n vector_to_plane = Vector.from_points(point, self.point)\n\n # Perpendicular vector from the point in space to the plane.\n vector_projected = self.normal.project_vector(vector_to_plane)\n\n return Point(point) + vector_projected","def polyPlane(*args, axis: Union[List[float, float, float], bool]=None, createUVs: Union[int,\n bool]=1, height: Union[float, bool]=1.0, subdivisionsHeight: Union[int, bool]=0,\n subdivisionsWidth: Union[int, bool]=10, subdivisionsX: Union[int, bool]=5,\n subdivisionsY: Union[int, bool]=5, texture: Union[int, bool]=1, width:\n Union[float, bool]=1.0, caching: bool=True, constructionHistory: bool=True, name:\n AnyStr=\"\", nodeState: Union[int, bool]=0, object: bool=True, q=True, query=True,\n e=True, edit=True, **kwargs)->Union[List[AnyStr], Any]:\n pass","def normal(self, point):\n return self._normal.dup()","def distance_point_plane(point, plane):\n base, normal = plane\n vector = subtract_vectors(point, base)\n return fabs(dot_vectors(vector, normal))","def test_surface_normal(self):\n vertices = np.array([[0, 1, 0], [0, 0, 0], [1, 0, 0]])\n expected = np.array([0, 0, 1])\n np.testing.assert_almost_equal(surface_normal(vertices), expected)\n\n # Test against multiple triangles\n vertices = np.r_[vertices[np.newaxis, :, :], [[[0, 0, 0], [0, 2, 0], [2, 0, 0]]]]\n expected = np.array([[0, 0, 1], [0, 0, -1]])\n np.testing.assert_almost_equal(surface_normal(vertices), expected)\n\n # Some real data\n vertices = np.array([[2.435, -1.82, -0.53], [2.635, -2., -0.58], [2.535, -1.7, -0.58]])\n expected = np.array([0.33424239, 0.11141413, 0.93587869])\n np.testing.assert_almost_equal(surface_normal(vertices), expected)\n\n # Test input validation\n self.assertRaises(ValueError, surface_normal, np.array([[1, 2, 3, 4]]))","def make_inward_normal(tetrahedron):\n\n convert_to_np_array = lambda v: np.array([v.x, v.y, v.z])\n np_vertices = list(map(convert_to_np_array, [tetrahedron.get_vertex(i) for i in range(4)]))\n # This is the middle point\n # midpoint = np.mean(np_vertices, axis=0)\n\n midpoint = np_vertices[0]\n for i in range(1, 4):\n midpoint += np_vertices[i]\n midpoint = midpoint / 2.0\n\n for i in range(4):\n face = tetrahedron.get_face(i)\n d = distance(face, midpoint)\n if d < 0:\n face.nx *= -1.0\n face.ny *= -1.0\n face.nz *= -1.0\n face.d *= -1.0","def project_3d_points_to_plane(points, p1, p2 ,p3, numpoints):\n p1 = np.asarray(p1)\n p2 = np.asarray(p2)\n p3 = np.asarray(p3)\n\n # get vectors in plane\n v1 = p3 - p1\n v2 = p2 - p1\n\n # compute cross product\n cp = np.cross(v1, v2)\n a, b, c = cp # normal to plane is ax + by + cz\n\n # evaluate d\n d = np.dot(cp, p3)\n\n # thus, normal is given by\n plane = vtk.vtkPlane()\n origin = p1\n normal = normalize(np.array([a,b,c]))\n plane.SetOrigin(p1)\n plane.SetNormal(normal)\n\n if numpoints == 1:\n proj = [0,0,0]\n plane.ProjectPoint(points, origin, normal, proj)\n return proj\n else:\n projected_pts = np.zeros((numpoints, 3), dtype=float)\n\n for i in range(numpoints):\n proj = [0,0,0]\n plane.ProjectPoint(points[i], origin, normal, proj)\n projected_pts[i] = proj\n\n return projected_pts","def get_normal_vector_of_plane(p1, p2, p3):\n v12 = np.array(p1) - np.array(p2)\n v13 = np.array(p1) - np.array(p3)\n nvec = np.cross(v12, v13)\n ## print 'norm: '+str(np.linalg.norm(nvec))\n return nvec / np.linalg.norm(nvec)","def get_plane(self, scalar, plane, pval):\n\n if plane == 'yz' or plane == 'zy':\n # z along rows, y along columns\n return scalar[:, pval, :]\n elif plane == 'xz' or plane == 'zx':\n # x along columns, z along rows\n return scalar[:, :, pval]\n elif plane == 'xy' or plane == 'yx':\n # x along rows, y along columns\n return scalar[pval, :, :]","def plane_sphere(p, s):\n\n p.normalize()\n\n d = dot(s.o-p.o, p.n)\n\n if d > s.r:\n return False\n else:\n return (s.o - d*p.n, sqrt(s.r*s.r - d*d))","def ProjectToPlane(self):\n\n self.__do_essential_memebers_exist__()\n if self.element_type != \"tri\":\n raise ValueError(\"Project to plane is only applicable to triangles\")\n\n imesh = deepcopy(self)\n coordinates = []\n connectivities = []\n for counter, elem in enumerate(imesh.elements):\n\n elementCoordinates = imesh.points[elem,:]\n\n A = elementCoordinates[0,:]\n B = elementCoordinates[1,:]\n C = elementCoordinates[2,:]\n\n X = (B - A); X /= np.linalg.norm(X)\n Z = np.cross(X, C - A); Z /= np.linalg.norm(Z)\n Y = np.cross(Z, X)\n\n # PROJECT THE TRIANGLE TO THIS BASES\n a = [0., 0.]\n b = [np.linalg.norm((B - A)), 0.]\n c = [(C - A).dot(X), (C - A).dot(Y)]\n\n coordinates.append(a)\n coordinates.append(b)\n coordinates.append(c)\n\n elementConnectivity = [3 * counter, 3 * counter + 1, 3 * counter + 2]\n connectivities.append(elementConnectivity)\n\n coordinates = np.array(coordinates)\n connectivities = np.array(connectivities)\n imesh.points = coordinates\n imesh.elements = connectivities\n imesh.nelem = imesh.elements.shape[0]\n imesh.nnode = imesh.points.shape[0]\n\n return imesh","def __copy__(self) -> 'Plane':\n return self.__class__(self._normal, self._distance_from_origin)","def normal(self) -> Vec:\n # The three points are in clockwise order, so compute differences\n # in the clockwise direction, then cross to get the normal.\n point_1 = self.planes[1] - self.planes[0]\n point_2 = self.planes[2] - self.planes[1]\n\n return Vec.cross(point_1, point_2).norm()","def add_planet(self,x,y,z):\n\t\tself.ob.append(vis.sphere(x=x, y=y, z=z, radius = 0.1))","def WritePlane(self):\n if not self.__train:\n print('ERROR: Must use Train before WritePlane')\n sys.exit(-1)\n if not self.__openPlaneO:\n print('ERROR: Must use OpenPlaneO before WritePlane')\n sys.exit(-1)\n\n # Defines angular dimensions\n self.__nc_RSoft_O.createDimension('type', self.__n_type)\n\n # Defines variables\n if self.__containsRadial:\n rad_plane_id = self.__nc_RSoft_O.createVariable(\\\n 'radial_plane', 'f4', \\\n ('type','radial_structure_functions'))\n rad_plane_id[:] = self.radial_plane\n if self.__containsAngular:\n ang_plane_id = self.__nc_RSoft_O.createVariable(\\\n 'angular_plane', 'f4', \\\n ('type','angular_structure_functions'))\n ang_plane_id[:] = self.angular_plane\n intercept_id_O = self.__nc_RSoft_O.createVariable(\\\n 'intercept', 'f4', ('type'))\n intercept_id_O[:] = self.intercept","def normal(self, point):\n point = self._center - np.array(point)\n # if abs(point.dot(point) - self._radius**2) > 1e-15:\n # raise RayTraceError(\n # 'Cannot compute normal. Point is too far from surface ({}).'.format(\n # (abs(point.dot(point) - self._radius**2))))\n return normalize(point / self._radius)","def surface_norm(self, pt):\n\n return self.normal.normalize()","def normal(axis_direction, axis_origin, point):\n # transform input into numpy arrays\n axis_direction = np.array(axis_direction, float)\n axis_origin = np.array(axis_origin, float)\n point = np.array(point, float)\n\n # vector from axis normal_origin to point\n vector = point - axis_origin\n\n # projection of vector on axis\n projection = np.dot(vector, axis_direction)*axis_direction\n\n # the normal vector from normal_origin to point\n normal_direction = vector - projection\n\n # normalized normal_direction\n normal_direction = normal_direction/np.linalg.norm(normal_direction)\n\n # opposite of the projection of vector on normal\n projection2 = - np.dot(normal_direction, vector)*normal_direction\n\n normal_origin = point + projection2\n\n return normal_direction, normal_origin","def __init__(self,\n r = 1.0,\n normal = Vector(0.0,1.0,0.0),\n origin = Vector(0.0,0.0,0.0),\n orientation = Vector(1.0,0.0,0.0),\n c1 = Color(0.01,0.01,0.01),\n c2 = Color(0.99,0.99,0.99)):\n \n CheckPlane.__init__(self, normal, origin, orientation, c1, c2)\n self.origin = origin\n self.set_orientation(orientation)\n self.r = r\n self.R = r ** 2.0","def plane_from_points(a, b, c):\n ab = subtract_vectors(b, a)\n ac = subtract_vectors(c, a)\n n = normalize_vector(cross_vectors(ab, ac))\n return a, n","def sample(self, z_position):\n if self.direction[2] != 0:\n z_plane = PlaneSurface([0, 0, 1], [0, 0, z_position])\n if (z_plane.position() - self.position).dot(self.direction) > 0:\n ray = self\n else:\n ray = Ray(-self.direction, self.position)\n return ray.propagate(z_plane.time_to_bound(ray)).position","def xzplane(draw, r, y, shift = np.array([1000, 1000, 0, 0]), scale = 300):\n extent = 2.8\n pln = np.array(\n [\n [-extent,y,0],\n [extent,y,0],\n [extent,y,extent*2],\n [-extent,y,extent*2]\n ]\n )\n pln = np.dot(pln, np.transpose(r))\n pln = pln * scale + shift[:3]\n draw.polygon([(pln[0][0],pln[0][1]),(pln[1][0],pln[1][1]),(pln[2][0],pln[2][1]),(pln[3][0],pln[3][1])], (0,102,255,70))","def invert_plane_stress(normal, slip, weights=None):\n nx, ny, nz = normal\n sx, sy, sz = slip\n\n Gx = np.zeros((nx.size, 3))\n Gx[:,0] = nx - nx**3 + nx*nz**2 \n Gx[:,1] = ny - 2*ny*nx**2\n Gx[:,2] = -nx*ny**2 + nx*nz**2\n \n Gy = np.zeros((nx.size, 3))\n Gy[:,0] = -ny*nx**2 + ny*nz**2\n Gy[:,1] = nx - 2*nx*ny**2\n Gy[:,2] = ny - ny**3 + ny*nz**2\n \n Gz = np.zeros((nx.size, 3))\n Gz[:,0] = -nz*nx**2 - nz + nz**3\n Gz[:,1] = -2*nx*ny*nz\n Gz[:,2] = -ny**2*nz - nz + nz**3\n\n\n G = np.vstack((Gx, Gy, Gz)).T\n d = np.hstack([sx,sy,sz])\n\n if weights is not None:\n weights = np.tile(weights, 3)\n G *= weights\n d *= weights\n\n m, residual, rank, sing_vals = np.linalg.lstsq(G.T,d.T)\n\n s11, s12, s22 = m\n s33 = -(s11 + s22)\n\n sigma = np.array([[s11, s12, 0.0],\n [s12, s22, 0.0],\n [0.0, 0.0, s33]])\n return sigma","def normal_at(self, world_point: Point) -> Vector:\n # Convert the world point and normal to shape space\n local_point = self.world_to_object(world_point)\n # Calculate the normal in shape space\n local_normal = self.local_normal_at(local_point)\n # Convert the local normal vector back to world space\n return self.normal_to_world(local_normal)","def plane_equation(p1, p2, p3):\n a1 = p2[0] - p1[0]\n b1 = p2[1] - p1[1]\n c1 = p2[2] - p1[2]\n a2 = p3[0] - p1[0]\n b2 = p3[1] - p1[1]\n c2 = p3[2] - p1[2]\n a = b1 * c2 - b2 * c1\n b = a2 * c1 - a1 * c2\n c = a1 * b2 - b1 * a2\n # Points are collinear\n if (abs(a) < 1e-6) and (abs(b) < 1e-6) and (abs(c) < 1e-6):\n return None\n # All clear\n d = (- a * p1[0] - b * p1[1] - c * p1[2])\n return a, b, c, d","def from_vector(cls, vector) -> 'Plane':\n v = Vector(vector)\n return Plane(v.normalize(), v.magnitude)","def planes_3d(self, quantity, xplane, yplane):\n xplane = int(xplane)\n yplane = int(yplane)\n # Get the scalar values\n # Get the data on the plane with a fixed x value. These means we'll\n # have changing (y, z) points\n xdata = self.get_plane(quantity, 'yz', xplane)\n # z first cuz we want y to be changing before z to correspond with the\n # way numpy flattens arrays. Note this means y points will be in the\n # 2nd column\n xplanepoints = np.array(list(itertools.product(self.Z, self.Y)))\n xdata = xdata.flatten()\n xplanexval = np.array(list(itertools.repeat(x[xplane], len(xdata))))\n xplanedata = np.zeros((xplanepoints.shape[0], 4))\n xplanedata[:, 0] = xplanexval\n xplanedata[:, 1] = xplanepoints[:, 1]\n xplanedata[:, 2] = xplanepoints[:, 0]\n xplanedata[:, 3] = xdata\n # Same procedure for fixed y plane\n ydata = self.get_plane(quantity, 'xz', yplane)\n yplanepoints = np.array(list(itertools.product(z, x)))\n ydata = ydata.flatten()\n yplaneyval = np.array(list(itertools.repeat(y[yplane], len(ydata))))\n yplanedata = np.zeros((yplanepoints.shape[0], 4))\n yplanedata[:, 0] = yplanepoints[:, 1]\n yplanedata[:, 1] = yplaneyval\n yplanedata[:, 2] = yplanepoints[:, 0]\n yplanedata[:, 3] = ydata\n labels = ('X [um]', 'Y [um]', 'Z [um]', quantity)\n # Now stack them vertically and plot!\n all_data = np.vstack((xplanedata, yplanedata))\n self.scatter3d(all_data[:, 0], all_data[:, 1], all_data[:, 2],\n all_data[:, 3], labels, 'planes_3d')","def build_coord(norm, d, pts):\n # Compute the origin as the mean point of the points, and this point has to be on the plane\n \n n = len(pts) \n x_total = 0\n y_total = 0\n z_total = 0\n \n for i in range(n):\n x_total += pts[i][0]\n y_total += pts[i][1]\n z_total += pts[i][2]\n\n x_o = x_total * 1.0 / n\n y_o = y_total * 1.0 / n\n z_o = z_total * 1.0 / n\n p_o = [x_o, y_o, z_o]\n \n # Choose p be the projection of a vector in the z-axis to the plane\n # If the plane is not perpendicular to the z-axis\n if ((norm[2] != 1) and (norm[2] != -1)): \n # Choose a point\n o_z = [x_o, y_o, z_o + 1]\n \n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\n \n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\n\n x_c = (x_p - x_o) * 1.0 / dist \n y_c = (y_p - y_o) * 1.0 / dist\n z_c = (z_p - z_o) * 1.0 / dist\n # Thus we have unit vector in x direction\n e_y = [x_c, y_c, z_c]\n #Compute the unit vector in y direction\n e_x = np.cross(e_y, norm).tolist()\n else:\n e_x = [1, 0, 0]\n e_y = [0, 1, 0]\n \n return [e_x, e_y, norm] , p_o","def planarize(self):\r\n from lsst.analysis import utils\r\n assert numpy.isfinite(self.z).all()\r\n self.z -= utils.evalplane(self.plane(), self.points)","def plot_surface(self):\n X, Y = np.meshgrid(self.x, self.y)\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n ax.plot_surface(X=X, Y=Y, Z=self.z)\n plt.show()","def build_coord(norm, d, pts):\n # Compute the origin as the mean point of the points, and this point has to be on the plane\n \n n = len(pts)\n x_total = 0\n y_total = 0\n z_total = 0\n \n for i in range(n):\n x_total += pts[i][0]\n y_total += pts[i][1]\n z_total += pts[i][2]\n\n x_o = x_total * 1.0 / n\n y_o = y_total * 1.0 / n\n z_o = z_total * 1.0 / n\n p_o = [x_o, y_o, z_o]\n \n # Choose p be the projection of a vector in the z-axis to the plane\n # If the plane is not perpendicular to the z-axis\n if ((norm[2] != 1) and (norm[2] != -1)): \n # Choose a point\n o_z = [x_o, y_o, z_o + 1]\n \n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\n \n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\n\n x_c = (x_p - x_o) * 1.0 / dist \n y_c = (y_p - y_o) * 1.0 / dist\n z_c = (z_p - z_o) * 1.0 / dist\n # Thus we have unit vector in x direction\n e_y = [x_c, y_c, z_c]\n #Compute the unit vector in y direction\n e_x = np.cross(e_y, norm).tolist()\n else:\n e_x = [1, 0, 0]\n e_y = [0, 1, 0]\n \n return [e_x, e_y, norm] , p_o","def project_points_plane(points, plane):\n return [project_point_plane(point, plane) for point in points]","def plot_projection(self, normal=(1, 1, 1), index_row=0, index_col=0, show=True, texture=None, cmap=\"jet\", f=None,\n plotter=None, title='', font_size=10, font_color='black'):\n if not plotter:\n plotter = pv.Plotter()\n plotter.subplot(index_column=index_col, index_row=index_row)\n\n plotter.add_text(title, position=\"upper_edge\", font_size=font_size, color=font_color)\n tex = None\n if texture:\n\n if isinstance(texture, np.ndarray):\n tex = pv.numpy_to_texture(texture)\n else:\n tex = pv.read_texture(texture)\n self.pv_mesh.texture_map_to_plane(inplace=True)\n # plotter.add_mesh(pv_mesh, texture=tex)\n\n og = self.pv_mesh.center\n projected = self.pv_mesh.project_points_to_plane(origin=og, normal=normal)\n projected.texture_map_to_plane()\n plotter.add_mesh(projected, texture=tex)\n if show:\n plotter.show()\n return plotter","def drawVector3D(x0,y0,z0,x1,y1,z1, vtype='normal'):\n dislin.vectr3(x0,y0,z0,x1,y1,z1, vectordict[vtype])","def surfaceRender(nodal_mesh, focus, ax=None):\n\t# If no axes were passed, generate new set of axes\n\tif not ax:\n\t\tfig = mplt.figure()\n\t\tax = fig.add_subplot(111, projection='3d')\n\n\t# Sort the mesh by first 3 columns\n\tnodal_mesh = nodal_mesh[nodal_mesh[:, 0].argsort()]\n\tnodal_mesh = nodal_mesh[nodal_mesh[:, 1].argsort(kind='mergesort')]\n\tnodal_mesh = nodal_mesh[nodal_mesh[:, 2].argsort(kind='mergesort')]\n\t\n\t# Set up number of divisions and calculate e for each division (as a ratio)\n\tnum_div = 20\n\te = [i/num_div for i in range(num_div + 1)]\n\t# Convert angular values from degrees to radians\n\trads = math.pi/180\n\tnodal_mesh[:, 1:3] *= rads\n\t# Store the shapes and sizes of the mesh values\n\tm = nodal_mesh.shape[0]\n\tsize_nodal_nu = np.where(nodal_mesh[:, 2] == 0)[0].size\n\tsize_nodal_phi = m/size_nodal_nu\n\t# Get the mu and theta values from the mesh\n\tnodal_nu = nodal_mesh[:size_nodal_nu, 1]\n\tnodal_phi = nodal_mesh[::size_nodal_nu, 2]\n\t# Convert apex node from prolate to cartesian, then plot with scatter\n\tif min(nodal_nu) == 0:\n\t\tx, y, z = mathhelper.prolate2cart(nodal_mesh[0, 0], nodal_mesh[0, 1], nodal_mesh[0, 2], focus)\n\t\tax.scatter(z, y, -x)\n\t\tstart_nu = 1\n\telse:\n\t\tstart_nu = 0\n\t# Plot circumferential element boundaries\n\tfor i in range(start_nu, size_nodal_nu):\n\t\tfor j in range(int(size_nodal_phi)):\n\t\t\t# Define nodal values for interpolation\n\t\t\tif j == size_nodal_phi-1:\n\t\t\t\tind0 = i\n\t\t\t\tp0 = 2*math.pi\n\t\t\telse:\n\t\t\t\tind0 = (j+1)*size_nodal_nu + i\n\t\t\t\tp0 = nodal_phi[j+1]\n\t\t\tind1 = (j)*size_nodal_nu + i\n\t\t\tp1 = nodal_phi[j]\n\t\t\t# Get mu and dM/dm1\n\t\t\tm0 = nodal_mesh[ind0, 0]\n\t\t\tdm0 = nodal_mesh[ind0, 3]\n\t\t\tm1 = nodal_mesh[ind1, 0]\n\t\t\tdm1 = nodal_mesh[ind1, 3]\n\t\t\t# Convert to cartesian\n\t\t\tn0x, n0y, n0z = mathhelper.prolate2cart(nodal_mesh[ind0, 0], nodal_mesh[ind0, 1], nodal_mesh[ind0, 2], focus)\n\t\t\t# Plot the node\n\t\t\tax.scatter(n0z, n0y, -n0x)\n\t\t\t# Plot the arc segments\n\t\t\tfor k in range(2, len(e)):\n\t\t\t\t# Determine starting point to use\n\t\t\t\tif k == 2:\n\t\t\t\t\tpt_x, pt_y, pt_z = n0x, n0y, n0z\n\t\t\t\telse:\n\t\t\t\t\tpt_x, pt_y, pt_z = x_here, y_here, z_here\n\t\t\t\t# Get lambda\n\t\t\t\thm0 = 1 - 3*(e[k]**2) + 2*(e[k]**3)\n\t\t\t\thdm0 = e[k]*(e[k] - 1)**2\n\t\t\t\thm1 = (e[k]**2)*(3 - 2*e[k])\n\t\t\t\thdm1 = (e[k]**2)*(e[k] - 1)\n\t\t\t\tm = hm0 * m0 + hdm0 * dm0 + hm1 * m1 + hdm1 * dm1\n\t\t\t\t# Get theta\n\t\t\t\tp_here = p0 - e[k]*(p0 - p1)\n\t\t\t\t# Convert to cartesian\n\t\t\t\tx_here, y_here, z_here = mathhelper.prolate2cart(m, nodal_nu[i], p_here, focus)\n\t\t\t\t# Create vectors\n\t\t\t\tx = np.append(pt_x, x_here)\n\t\t\t\ty = np.append(pt_y, y_here)\n\t\t\t\tz = np.append(pt_z, z_here)\n\t\t\t\t# Plot segments\n\t\t\t\tax.plot(z, y, -x, 'k-.')\n\t# Plot longitudinal element boundaries\n\tfor i in range(int(size_nodal_phi)):\n\t\tfor j in range(size_nodal_nu-1):\n\t\t\t# Define nodal values needeed for interpolation\n\t\t\tind0 = i*size_nodal_nu + j\n\t\t\tind1 = ind0 + 1\n\t\t\tn0 = nodal_nu[j]\n\t\t\tn1 = nodal_nu[j+1]\n\t\t\t# Get lambda and dL/de2\n\t\t\tm0 = nodal_mesh[ind0, 0]\n\t\t\tdm0 = nodal_mesh[ind0, 4]\n\t\t\tm1 = nodal_mesh[ind1, 0]\n\t\t\tdm1 = nodal_mesh[ind1, 4]\n\t\t\t# Convert nodal points to cartesian\n\t\t\tn0x, n0y, n0z = mathhelper.prolate2cart(nodal_mesh[ind0, 0], nodal_mesh[ind0, 1], nodal_mesh[ind0, 2], focus)\n\t\t\t# Plot arc\n\t\t\tfor k in range(2, len(e)):\n\t\t\t\t# Determine point to use\n\t\t\t\tif k == 2:\n\t\t\t\t\tpt_x, pt_y, pt_z = n0x, n0y, n0z\n\t\t\t\telse:\n\t\t\t\t\tpt_x, pt_y, pt_z = x_here, y_here, z_here\n\t\t\t\t# Get lambda\n\t\t\t\thm0 = 1 - 3*(e[k]**2) + 2*(e[k]**3)\n\t\t\t\thdm0 = e[k]*(e[k] - 1)**2\n\t\t\t\thm1 = (e[k]**2)*(3 - 2*e[k])\n\t\t\t\thdm1 = (e[k]**2)*(e[k] - 1)\n\t\t\t\tm = hm0 * m0 + hdm0 * dm0 + hm1 * m1 + hdm1 * dm1\n\t\t\t\t# Get nu\n\t\t\t\tn_here = n0 + e[k]*(n1-n0)\n\t\t\t\t# Convert to cartesian\n\t\t\t\tx_here, y_here, z_here = mathhelper.prolate2cart(m, n_here, nodal_phi[i], focus)\n\t\t\t\t# Append the vectors for plotting\n\t\t\t\tx = np.append(pt_x, x_here)\n\t\t\t\ty = np.append(pt_y, y_here)\n\t\t\t\tz = np.append(pt_z, z_here)\n\t\t\t\t# Plot the segment\n\t\t\t\tax.plot(z, y, -x, 'k-.')\n\t\t\t\t\n\treturn(ax)","def random_plane_points(num_points, bounds):\n\n # Infer dimension of data from bounds\n (bounds, dimension) = infer_dimension(bounds)\n\n # Generate points and rescale to fit bounds\n points = np.random.rand(num_points, dimension)\n unit_mean = [0.5] * dimension\n shifted_points = points - unit_mean + bounds.mean(axis=1)\n scale = bounds[:, 1] - bounds[:, 0]\n rescaled_points = np.dot(shifted_points, np.diag(scale))\n\n return rescaled_points","def plane_2d(self, quantity, plane, pval, draw=False, fixed=None):\n self.log.info('Plotting plane')\n pval = int(pval)\n # x = np.arange(0, self.period, self.dx)\n # y = np.arange(0, self.period, self.dy)\n # z = np.arange(0, self.height + self.dz, self.dz)\n x = self.X\n y = self.Y\n z = self.Z\n # Get the scalar values\n freq = self.conf['Simulation']['params']['frequency']\n wvlgth = (consts.c / freq) * 1E9\n title = 'Frequency = {:.4E} Hz, Wavelength = {:.2f} nm'.format(\n freq, wvlgth)\n # Get the plane we wish to plot\n cs = self.get_plane(quantity, plane, pval)\n self.log.info('DATA SHAPE: %s' % str(cs.shape))\n show = self.conf['General']['show_plots']\n p = False\n sim_dir = os.path.expandvars(self.conf['General']['sim_dir'])\n if plane == 'yz' or plane == 'zy':\n labels = ('y [um]', 'z [um]', quantity, title)\n if self.conf['General']['save_plots']:\n p = os.path.join(sim_dir,\n '%s_plane_2d_yz_pval%s.png' % (quantity,\n str(pval)))\n self.heatmap2d(y, z, cs, labels, plane, pval,\n save_path=p, show=show, draw=draw, fixed=fixed)\n elif plane == 'xz' or plane == 'zx':\n labels = ('x [um]', 'z [um]', quantity, title)\n if self.conf['General']['save_plots']:\n p = os.path.join(sim_dir,\n '%s_plane_2d_xz_pval%s.png' % (quantity,\n str(pval)))\n self.heatmap2d(x, z, cs, labels, plane, pval,\n save_path=p, show=show, draw=draw, fixed=fixed)\n elif plane == 'xy' or plane == 'yx':\n labels = ('y [um]', 'x [um]', quantity, title)\n if self.conf['General']['save_plots']:\n p = os.path.join(sim_dir,\n '%s_plane_2d_xy_pval%s.png' % (quantity,\n str(pval)))\n self.heatmap2d(x, y, cs, labels, plane, pval,\n save_path=p, show=show, draw=draw, fixed=fixed)","def get_transformable_plane(self, x_range = None, y_range = None):\n plane_config = dict(self.plane_config)\n shift_val = ORIGIN\n if x_range is not None:\n x_min, x_max = x_range\n plane_config[\"x_radius\"] = x_max - x_min\n shift_val += (x_max+x_min)*RIGHT/2.\n if y_range is not None:\n y_min, y_max = y_range\n plane_config[\"y_radius\"] = y_max - y_min\n shift_val += (y_max+y_min)*UP/2.\n plane = ComplexPlane(**plane_config)\n plane.shift(shift_val)\n if self.use_multicolored_plane:\n self.paint_plane(plane)\n return plane","def from_vectors(cls, point: array_like, vector_a: array_like, vector_b: array_like, **kwargs) -> Plane:\n vector_a = Vector(vector_a)\n\n if vector_a.is_parallel(vector_b, **kwargs):\n raise ValueError(\"The vectors must not be parallel.\")\n\n # The cross product returns a 3D vector.\n vector_normal = vector_a.cross(vector_b)\n\n # Convert the point to 3D so that it matches the vector dimension.\n point = Point(point).set_dimension(3)\n\n return cls(point, vector_normal)","def boom_plane(self):\n return Plane(reference=self.tail_shaft_circle[0].center,\n normal=Vector(0, 1, 0),\n binormal=Vector(0, 0, 1))","def normal(self, t=0):\n n = Line3d()\n n.p = self.lerp(t)\n n.v = self.cross\n return n","def xyplane(draw, r, x, shift = np.array([1000, 1000, 0, 0]), scale = 300):\n extent = 2.8\n pln = np.array(\n [\n [x,-extent,0],\n [x,extent,0],\n [x,extent,extent*2],\n [x,-extent,extent*2]\n ]\n )\n pln = np.dot(pln,np.transpose(r))\n pln = pln * scale + shift[:3]\n draw.polygon([(pln[0][0],pln[0][1]),(pln[1][0],pln[1][1]),(pln[2][0],pln[2][1]),(pln[3][0],pln[3][1])], (0,102,255,70))","def plane_point_side_v3(p: np.ndarray, v: np.ndarray) -> Any:\n return p[:3].dot(v) + p[3]","def intersect_plane(self, other: Plane, **kwargs) -> Line:\n if self.normal.is_parallel(other.normal, **kwargs):\n raise ValueError(\"The planes must not be parallel.\")\n\n array_normals_stacked = np.vstack((self.normal, other.normal))\n\n # Construct a matrix for a linear system.\n array_00 = 2 * np.eye(3)\n array_01 = array_normals_stacked.T\n array_10 = array_normals_stacked\n array_11 = np.zeros((2, 2))\n matrix = np.block([[array_00, array_01], [array_10, array_11]])\n\n dot_a = np.dot(self.point, self.normal)\n dot_b = np.dot(other.point, other.normal)\n array_y = np.array([0, 0, 0, dot_a, dot_b])\n\n # Solve the linear system.\n solution = np.linalg.solve(matrix, array_y)\n\n point_line = Point(solution[:3])\n direction_line = self.normal.cross(other.normal)\n\n return Line(point_line, direction_line)","def get_plane(self, quantity, plane, pval):\n\n self.log.info('Retrieving plane for %s', quantity)\n scalar = self.get_scalar_quantity(quantity)\n if plane == 'yz' or plane == 'zy':\n # z along rows, y along columns\n return scalar[:, pval, :]\n elif plane == 'xz' or plane == 'zx':\n # x along columns, z along rows\n return scalar[:, :, pval]\n elif plane == 'xy' or plane == 'yx':\n # x along rows, y along columns\n return scalar[pval, :, :]"],"string":"[\n \"def project_point_plane(point, plane):\\n base, normal = plane\\n normal = normalize_vector(normal)\\n vector = subtract_vectors(point, base)\\n snormal = scale_vector(normal, dot_vectors(vector, normal))\\n return subtract_vectors(point, snormal)\",\n \"def plot_plane(unit_normal, x_array, y_array, fore):\\n # print'unit normal = ', unit_normal\\n z = (((unit_normal[0] * (fore[0] - x_array)) + (unit_normal[1] * (fore[1] - y_array))) / unit_normal[2]) + fore[2]\\n # print 'plane numbers\\\\n', z\\n return z\",\n \"def plane(self):\\r\\n from lsst.analysis import utils\\r\\n return utils.fitplane(self.points, self.z)\",\n \"def mirror_point_to_plane(point, plane):\\n assert isinstance(plane, cg3d_plane.CGPlane)\\n pn, norm = plane.get_point_and_normal()\\n norm.normalize()\\n return point - 2.0 * ((point - pn) * norm) * norm\",\n \"def get_plane_of_points(\\n self,\\n normal_vector=\\\"z\\\",\\n planar_coordinate=None,\\n ):\\n # Get results vectors\\n if (normal_vector == \\\"z\\\"):\\n x_flat = self.floris.grid.x_sorted_inertial_frame[0, 0].flatten()\\n y_flat = self.floris.grid.y_sorted_inertial_frame[0, 0].flatten()\\n z_flat = self.floris.grid.z_sorted_inertial_frame[0, 0].flatten()\\n else:\\n x_flat = self.floris.grid.x_sorted[0, 0].flatten()\\n y_flat = self.floris.grid.y_sorted[0, 0].flatten()\\n z_flat = self.floris.grid.z_sorted[0, 0].flatten()\\n u_flat = self.floris.flow_field.u_sorted[0, 0].flatten()\\n v_flat = self.floris.flow_field.v_sorted[0, 0].flatten()\\n w_flat = self.floris.flow_field.w_sorted[0, 0].flatten()\\n\\n # Create a df of these\\n if normal_vector == \\\"z\\\":\\n df = pd.DataFrame(\\n {\\n \\\"x1\\\": x_flat,\\n \\\"x2\\\": y_flat,\\n \\\"x3\\\": z_flat,\\n \\\"u\\\": u_flat,\\n \\\"v\\\": v_flat,\\n \\\"w\\\": w_flat,\\n }\\n )\\n if normal_vector == \\\"x\\\":\\n df = pd.DataFrame(\\n {\\n \\\"x1\\\": y_flat,\\n \\\"x2\\\": z_flat,\\n \\\"x3\\\": x_flat,\\n \\\"u\\\": u_flat,\\n \\\"v\\\": v_flat,\\n \\\"w\\\": w_flat,\\n }\\n )\\n if normal_vector == \\\"y\\\":\\n df = pd.DataFrame(\\n {\\n \\\"x1\\\": x_flat,\\n \\\"x2\\\": z_flat,\\n \\\"x3\\\": y_flat,\\n \\\"u\\\": u_flat,\\n \\\"v\\\": v_flat,\\n \\\"w\\\": w_flat,\\n }\\n )\\n\\n # Subset to plane\\n # TODO: Seems sloppy as need more than one plane in the z-direction for GCH\\n if planar_coordinate is not None:\\n df = df[np.isclose(df.x3, planar_coordinate)] # , atol=0.1, rtol=0.0)]\\n\\n # Drop duplicates\\n # TODO is this still needed now that we setup a grid for just this plane?\\n df = df.drop_duplicates()\\n\\n # Sort values of df to make sure plotting is acceptable\\n df = df.sort_values([\\\"x2\\\", \\\"x1\\\"]).reset_index(drop=True)\\n\\n return df\",\n \"def plane(self):\\n return plane(self.N, self.o)\",\n \"def plane_equation(point_a, point_b, point_c):\\n v1 = np.subtract(point_a, point_c)\\n v2 = np.subtract(point_a, point_b)\\n normal = np.cross(v1, v2)\\n # print 'b4 norm', normal\\n unit_normal = norm_vect(normal)\\n # print 'unityyy', unit_normal\\n return unit_normal\",\n \"def get_plane(\\n self,\\n pos=None,\\n norm=None,\\n plane=None,\\n sx=None,\\n sy=None,\\n color=\\\"lightgray\\\",\\n alpha=0.25,\\n **kwargs,\\n ):\\n axes_pairs = dict(sagittal=(0, 1), horizontal=(2, 0), frontal=(2, 1))\\n\\n if pos is None:\\n pos = self.root._mesh.centerOfMass()\\n\\n try:\\n norm = norm or self.space.plane_normals[plane]\\n except KeyError: # pragma: no cover\\n raise ValueError( # pragma: no cover\\n f\\\"Could not find normals for plane {plane}. Atlas space provides these normals: {self.space.plane_normals}\\\" # pragma: no cover\\n )\\n\\n # Get plane width and height\\n idx_pair = (\\n axes_pairs[plane]\\n if plane is not None\\n else axes_pairs[\\\"horizontal\\\"]\\n )\\n\\n bounds = self.root.bounds()\\n root_bounds = [\\n [bounds[0], bounds[1]],\\n [bounds[2], bounds[3]],\\n [bounds[4], bounds[5]],\\n ]\\n\\n wh = [float(np.diff(root_bounds[i])) for i in idx_pair]\\n if sx is None:\\n sx = wh[0]\\n if sy is None:\\n sy = wh[1]\\n\\n # return plane\\n return Actor(\\n Plane(pos=pos, normal=norm, sx=sx, sy=sy, c=color, alpha=alpha),\\n name=f\\\"Plane at {pos} norm: {norm}\\\",\\n br_class=\\\"plane\\\",\\n )\",\n \"def plane(self):\\n return Plane(Point(0, self.evaluations.exposedWing.edges[2].point1.y, 0), Vector(0, 1, 0),\\n hidden=True)\",\n \"def create_surface_plane(align_to = None, axis = 'x', width = 0.5, freeze_tm = True):\\n axis_dict = {'x': (1, 0, 0), 'y': (0, 1, 0), 'z': (0, 0, 1)}\\n res = pm.nurbsPlane(\\n axis = axis_dict[axis],\\n width = width,\\n degree = 1,\\n constructionHistory = False\\n )[0]\\n if align_to is not None:\\n transformation.align(res, align_to)\\n if freeze_tm:\\n transformation.freeze_transform(res)\\n return res\",\n \"def __init__(self, normal, position, name=None, reflective=False):\\n _Surface.__init__(self, name, reflective)\\n self._normal = normalize(normal)\\n self._position = np.array(position)\",\n \"def fit_plane(xyz,z_pos=None):\\n mean = np.mean(xyz,axis=0)\\n xyz_c = xyz - mean[None,:]\\n l,v = np.linalg.eig(xyz_c.T.dot(xyz_c))\\n abc = v[:,np.argmin(l)]\\n d = -np.sum(abc*mean)\\n # unit-norm the plane-normal:\\n abcd = np.r_[abc,d]/np.linalg.norm(abc)\\n # flip the normal direction:\\n if z_pos is not None:\\n if np.sum(abcd[:3]*z_pos) < 0.0:\\n abcd *= -1\\n return abcd\",\n \"def add_rectangular_plane(center_loc=(0, 0, 0), point_to=(0, 0, 1), size=(2, 2), name=None):\\n center_loc = np.array(center_loc)\\n point_to = np.array(point_to)\\n size = np.append(np.array(size), 0)\\n\\n bpy.ops.mesh.primitive_plane_add(location=center_loc)\\n\\n plane_obj = bpy.context.object\\n\\n if name is not None:\\n plane_obj.name = name\\n\\n plane_obj.dimensions = size\\n\\n # Point it to target\\n direction = Vector(point_to) - plane_obj.location\\n # Find quaternion that rotates plane's 'Z' so that it aligns with 'direction'\\n # This rotation is not unique because the rotated plane can still rotate about direction vector\\n # Specifying 'Y' gives the rotation quaternion with plane's 'Y' pointing up\\n rot_quat = direction.to_track_quat('Z', 'Y')\\n plane_obj.rotation_euler = rot_quat.to_euler()\\n\\n # Scene update necessary, as matrix_world is updated lazily\\n bpy.context.scene.update()\\n\\n return plane_obj\",\n \"def _prepare_plane(self):\\n verticies = [\\n # main plane - note that the mainplane is scaled so the mat_plane\\n # matrix will it transform to the correct coordinates\\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\\n -self.i_border[0]/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], -(self.o_wh[1]-self.i_border[1])/self._scaling[1],\\n (self.o_wh[0]-self.i_border[0])/self._scaling[0], self.i_border[1]/self._scaling[1],\\n -self.i_border[0]/self._scaling[0], self.i_border[1]/self._scaling[1],\\n\\n # coord plane\\n 0, 0,\\n 0, -self.o_wh[1],\\n self.o_wh[0], -self.o_wh[1],\\n self.o_wh[0], -self.o_wh[1],\\n self.o_wh[0], 0,\\n 0, 0,\\n\\n # axes\\n 0, -self.o_wh[1], self.o_wh[0], -self.o_wh[1], #x\\n 0, 0, 0, -self.o_wh[1], #y\\n ]\\n\\n colors = [\\n 1.0, 1.0, 1.0, 1.0, # outer box XXX Remove outer box...\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n 1.0, 1.0, 1.0, 1.0,\\n .9, .9, .9, 9.0, # plot box\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n .9, .9, .9, 9.0,\\n 0.0, 0.0, 0.0, 1.0, #lines\\n 0.0, 0.0, 0.0, 1.0,\\n 0.0, 0.0, 0.0, 1.0,\\n 0.0, 0.0, 0.0, 1.0,\\n ]\\n\\n self._fonts = []\\n for u in range(1, self._unit_count[0]+1):\\n verticies.append(self._unit_w[0]*u)\\n verticies.append(-self.o_wh[1]+0.02)\\n verticies.append(self._unit_w[0]*u)\\n verticies.append(-self.o_wh[1]-0.02)\\n colors += [0.0, 0.0, 0.0, 1.0]\\n colors += [0.0, 0.0, 0.0, 1.0]\\n self._fonts.append([\\n '{:.2f}'.format(u*(self.i_axis[0]/self._unit_count[0])-self.i_origin[0]),\\n (self._unit_w[0]*u+self.i_border[0]-0.05)*self._scaling[0],\\n (-self.o_wh[1]+(self.i_border[3])*0.5)\\n ])\\n for u in range(0, self._unit_count[1]):\\n verticies.append(0.02)\\n verticies.append(-self._unit_w[1]*u)\\n verticies.append(-0.02)\\n verticies.append(-self._unit_w[1]*u)\\n colors += [0.0, 0.0, 0.0, 1.0]\\n colors += [0.0, 0.0, 0.0, 1.0]\\n self._fonts.append([\\n '{:.2f}'.format(self.i_axis[1]-u*self.i_axis[1]/self._unit_count[1]-self.i_origin[1]),\\n (0.025)*self._scaling[0],\\n (-(self._unit_w[1])*u-self.i_border[1]+0.01)*self._scaling[1]\\n ])\\n\\n self._draw_plane_indicies = (0, 12)\\n self._draw_line_indicies = (12, 4+self._unit_count[0]*2+self._unit_count[1]*2)\\n\\n # convert data into valid data format\\n verticies = numpy.array(verticies, dtype=numpy.float32)\\n colors = numpy.array(colors, dtype=numpy.float32)\\n\\n self._plane_vao = util.VAO()\\n self._plane_vbo = util.VBO(2)\\n\\n with self._plane_vao:\\n # plane verticies\\n with self._plane_vbo.get(0):\\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(verticies), verticies, GL_STATIC_DRAW)\\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_position'), 2, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(0)\\n\\n # place vertex colors\\n with self._plane_vbo.get(1):\\n glBufferData(GL_ARRAY_BUFFER, ArrayDatatype.arrayByteCount(colors), colors, GL_STATIC_DRAW)\\n glVertexAttribPointer(self.plane_shader.attributeLocation('vertex_color'), 4, GL_FLOAT, GL_FALSE, 0, None)\\n glEnableVertexAttribArray(1)\",\n \"def plane(*args, length: float=0.0, name: AnyStr=\\\"\\\", position: List[float, float, float]=None,\\n rotation: List[float, float, float]=None, size: float=0.0, width: float=0.0,\\n **kwargs)->AnyStr:\\n pass\",\n \"def point_and_plane_pose(plane_point, plane_orientation, points=None, xyz=None):\\n vector = plane_orientation\\n vector = vector / np.linalg.norm(vector)\\n a = vector[0]\\n b = vector[1]\\n c = vector[2]\\n\\n d = -a * plane_point[0] - b * plane_point[1] - c * plane_point[2]\\n\\n if xyz is not None:\\n xyz = np.asarray(xyz)\\n if points.shape[0] != 3:\\n logger.error(\\n \\\"Wrong points shape. [3, N] expected, \\\" + str(points.shape) + \\\" given.\\\"\\n )\\n elif points is not None:\\n points = np.asarray(points)\\n if points.shape[1] != 3:\\n logger.error(\\n \\\"Wrong points shape. [N, 3] expected, \\\" + str(points.shape) + \\\" given.\\\"\\n )\\n xyz = points.T\\n else:\\n logger.error(\\\"points or xyz must be declared\\\")\\n\\n x, y, z = xyz\\n z_out = (a * x + b * y + c * z + d) / (a ** 2 + b ** 2 + c ** 2) ** 0.5\\n\\n return z_out\",\n \"def _fit_plane_to_point_cloud(\\n points_xyz: NDArrayFloat,\\n) -> Tuple[float, float, float, float]:\\n center_xyz: NDArrayFloat = np.mean(points_xyz, axis=0)\\n out: Tuple[NDArrayFloat, NDArrayFloat, NDArrayFloat] = np.linalg.svd(\\n points_xyz - center_xyz\\n )\\n vh = out[2]\\n\\n # Get the unitary normal vector\\n a, b, c = float(vh[2, 0]), float(vh[2, 1]), float(vh[2, 2])\\n d: float = -np.dot([a, b, c], center_xyz)\\n return (a, b, c, d)\",\n \"def get_surface_normals_o3d(normals, points, scale=2):\\n # total number of points:\\n N = points.shape[0]\\n\\n points = np.vstack(\\n (points.to_numpy(), points.to_numpy() + scale * normals)\\n )\\n lines = [[i, i+N] for i in range(N)]\\n colors = np.zeros((N, 3)).tolist()\\n\\n # build pca line set:\\n surface_normals_o3d = o3d.geometry.LineSet(\\n points=o3d.utility.Vector3dVector(points),\\n lines=o3d.utility.Vector2iVector(lines),\\n )\\n surface_normals_o3d.colors = o3d.utility.Vector3dVector(colors)\\n\\n return surface_normals_o3d\",\n \"def xyz2plane(x,y,z, new_x=[], plane=[], origin=None):\\n # preliminary stuff\\n if origin != None: x = x - origin\\n a,b,c,d = plane\\n bottom = np.sqrt(a*a + b*b + c*c) # normalize\\n a,b,c,d = a/bottom, b/bottom, c/bottom, d/bottom\\n px, py, pz = new_x\\n bot = np.sqrt(px*px + py*py + pz*pz) #normalize\\n px, py, pz = px/bot, py/bot, pz/bot\\n p0 = [px,py,pz]\\n # do rotation\\n z_hat = [a,b,c]\\n y_hat = cross(z_hat, p0)\\n x_hat = cross(y_hat, z_hat)\\n if type(x)==type(arr) or type(x)==type([]):\\n xp, yp, zp = [], [], []\\n for i in range(len(x)):\\n xp.append(dot([x[i],y[i],z[i]], x_hat))\\n yp.append(dot([x[i],y[i],z[i]], y_hat))\\n zp.append(dot([x[i],y[i],z[i]], z_hat))\\n else:\\n xp = dot([x,y,z], x_hat)\\n yp = dot([x,y,z], y_hat)\\n zp = dot([x,y,z], z_hat)\\n return xp, yp, zp\",\n \"def alpha_surface_reconstruction(pcd, alpha=10):\\n road_mesh = o3d.geometry.TriangleMesh.create_from_point_cloud_alpha_shape(pcd, alpha)\\n vertices = np.asarray(copy.deepcopy(road_mesh.vertices)) #flatten road mesh\\n vertices[:,2] = 0\\n flattend_mesh = copy.deepcopy(road_mesh)\\n flattend_mesh.vertices = o3d.utility.Vector3dVector(vertices)\\n return flattend_mesh, road_mesh\",\n \"def test_CoordinatePlane(self):\\n origin = np.random.randn(3)\\n normal = np.random.randn(3)\\n up_vector = np.random.randn(3)\\n plane = shapes_nd.Plane(origin, normal)\\n cplane = shapes_3d.CoordinatePlane(origin, normal, up_vector)\\n \\n np.testing.assert_almost_equal(cplane.dim, plane.dim)\\n np.testing.assert_almost_equal(cplane.origin, plane.origin)\\n np.testing.assert_almost_equal(cplane.normal, plane.normal)\\n \\n p3 = [0, 1, 0]\\n c, d = cplane.project_point(p3, ret_dist=True)\\n np.testing.assert_almost_equal(p3, cplane.revert_projection(c, d))\\n p3 = np.random.randn(5, 3)\\n c, d = cplane.project_point(p3, ret_dist=True)\\n np.testing.assert_almost_equal(p3, cplane.revert_projection(c, d))\",\n \"def __init__(self, t, point=None, normal=None, uv=None, material=None):\\n self.t = t\\n self.point = point\\n self.normal = normal\\n self.uv = uv\\n self.material = material\",\n \"def addPlaneToScene(self, foot, x, y):\\r\\n #research\\r\\n profprint()\\r\\n scene = slicer.mrmlScene\\r\\n # Create model node\\r\\n model = slicer.vtkMRMLModelNode()\\r\\n model.SetScene(scene)\\r\\n model.SetName(scene.GenerateUniqueName(\\\".ObturatorPlane\\\"))\\r\\n\\r\\n planeSource = vtk.vtkPlaneSource()\\r\\n foot-=25*(x+y)\\r\\n #planeSource.SetOrigin(np.array(foot))\\r\\n planeSource.SetOrigin(list(foot))\\r\\n planeSource.SetPoint1(np.array(foot)+50*x)\\r\\n planeSource.SetPoint2(np.array(foot)+50*y)\\r\\n planeSource.Update()\\r\\n model.SetAndObservePolyData(planeSource.GetOutput())\\r\\n\\r\\n # Create display node\\r\\n modelDisplay = slicer.vtkMRMLModelDisplayNode()\\r\\n modelDisplay.SetColor(1,1,0) # yellow\\r\\n modelDisplay.SetBackfaceCulling(0)\\r\\n modelDisplay.SetScene(scene)\\r\\n scene.AddNode(modelDisplay)\\r\\n model.SetAndObserveDisplayNodeID(modelDisplay.GetID())\\r\\n\\r\\n # Add to scene\\r\\n scene.AddNode(model)\\r\\n # transform = slicer.vtkMRMLLinearTransformNode()\\r\\n # scene.AddNode(transform)\\r\\n # model.SetAndObserveTransformNodeID(transform.GetID())\\r\\n #\\r\\n # vTransform = vtk.vtkTransform()\\r\\n # vTransform.Scale(50,50,50)\\r\\n # #vTransform.RotateX(30)\\r\\n # transform.SetAndObserveMatrixTransformToParent(vTransform.GetMatrix())\\r\",\n \"def hyperplane(self):\\n origin = (self.a+self.b+self.c)/3.\\n normal = np.cross(self.a-self.b, self.a-self.c)\\n return Hyperplane(origin, normal)\",\n \"def draw_plane(env, transform, extents=(4,4), texture=None):\\n if texture is None:\\n texture = np.zeros((100,100,4))\\n texture[:,:,1] = 0.2\\n texture[:,:,2] = 0.2\\n texture[:,:,3] = 0.2\\n with env:\\n h = env.drawplane(transform, extents=extents, texture=texture)\\n return h\",\n \"def surface(*args, degreeU: int=0, degreeV: int=0, formU: AnyStr=\\\"\\\", formV: AnyStr=\\\"\\\", knotU:\\n Union[float, List[float]]=0.0, knotV: Union[float, List[float]]=0.0, name:\\n AnyStr=\\\"\\\", objectSpace: bool=True, point: Union[List[float, float, float],\\n List[List[float, float, float]]]=None, pointWeight: Union[List[float, float, float,\\n float], List[List[float, float, float, float]]]=None, worldSpace: bool=True,\\n **kwargs)->AnyStr:\\n pass\",\n \"def SetNormal(self, *args):\\n return _itkSurfaceSpatialObjectPointPython.itkSurfaceSpatialObjectPoint3_SetNormal(self, *args)\",\n \"def SetPlaneMode(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_ConvertSurfaceToBezierBasis_SetPlaneMode(self, *args)\",\n \"def _update_surface_normals(self):\\n\\n # This is the case if there are too few points to\\n # compute normals so there can be values to remove\\n\\n #can be important for parallel\\n self.swarm.shadow_particles_fetch()\\n\\n if self.empty:\\n self.director.data[...] = 0.0\\n else:\\n\\n particle_coords = self.swarm.particleCoordinates.data\\n\\n Nx = np.empty(self.swarm.particleLocalCount)\\n Ny = np.empty(self.swarm.particleLocalCount)\\n Nz = np.empty(self.swarm.particleLocalCount)\\n\\n for i, xyz in enumerate(particle_coords):\\n r, neighbours = self.kdtree.query(particle_coords[i], k=4)\\n\\n # this point is neighbour[0] and neighbour points are neighbours[(1,2,3)]\\n XYZ1 = self.kdtree.data[neighbours[1]]\\n XYZ2 = self.kdtree.data[neighbours[2]]\\n XYZ3 = self.kdtree.data[neighbours[3]]\\n\\n dXYZ1 = XYZ2 - XYZ1\\n dXYZ2 = XYZ3 - XYZ1\\n\\n # Cross product of those 2 vectors can be use as the local normal (perhaps)\\n\\n Nx[i], Ny[i], Nz[i] = np.cross(dXYZ1, dXYZ2)\\n #if i == 0:\\n # print(Nx, Ny, Nz)\\n # print(xyz[0], xyz[1],xyz[2])\\n # print((self.insidePt[0] - xyz[0]) * Nx[i] )\\n\\n if (self.insidePt):\\n sign = np.sign( (self.insidePt[0] - xyz[0]) * Nx[i] +\\n (self.insidePt[1] - xyz[1]) * Ny[i] +\\n (self.insidePt[2] - xyz[2]) * Nz[i] )\\n Nx[i] *= sign\\n Ny[i] *= sign\\n Nz[i] *= sign\\n\\n\\n for i in range(0, self.swarm.particleLocalCount):\\n scale = 1.0 / np.sqrt(Nx[i]**2 + Ny[i]**2 + Nz[i]**2)\\n Nx[i] *= scale\\n Ny[i] *= scale\\n Nz[i] *= scale\\n\\n\\n self.director.data[:,0] = Nx[:]\\n self.director.data[:,1] = Ny[:]\\n self.director.data[:,2] = Nz[:]\\n\\n print(\\\"Surf Norms\\\")\\n\\n return\",\n \"def test_create(self):\\n f = azplugins.restrain.plane(group=hoomd.group.all(), point=(0,0,0), normal=(1,0,0), k=2.0)\\n\\n f.set_params(k=5.0)\\n f.set_params(k=8)\\n\\n f.set_params(point=(0,0,1))\\n f.set_params(point=[0,0,1])\\n f.set_params(point=np.array([0,0,1]))\\n\\n f.set_params(normal=(0,0,1))\\n f.set_params(normal=[0,0,1])\\n f.set_params(normal=np.array([0,0,1]))\\n\\n f.set_params(point=(0,0,0), normal=(1,0,0), k=10.0)\",\n \"def GetPlane(plane):\\r\\n pass\",\n \"def project_onto_plane(vect):\\n x, y, z = vect\\n \\n return (x, y, 0.)\",\n \"def closest_point_on_plane(point, plane):\\n base, normal = plane\\n x, y, z = base\\n a, b, c = normalize_vector(normal)\\n x1, y1, z1 = point\\n d = a * x + b * y + c * z\\n k = (a * x1 + b * y1 + c * z1 - d) / (a**2 + b**2 + c**2)\\n return [x1 - k * a,\\n y1 - k * b,\\n z1 - k * c]\",\n \"def fit_plane_to_points(points: np.ndarray, eps: float=1.0e-5):\\n # Compute plane origin and subract it from the points array.\\n plane_origin = np.mean(points, axis=0)\\n x = points - plane_origin\\n\\n # Dot product to yield a 3x3 array.\\n moment = np.dot(x.T, x)\\n\\n # Extract single values from SVD computation to get normal.\\n plane_normal = np.linalg.svd(moment)[0][:,-1]\\n small = np.where(np.abs(plane_normal) < eps)\\n plane_normal[small] = 0.0\\n plane_normal /= np.linalg.norm(plane_normal)\\n if (plane_normal[-1] < 0.0):\\n plane_normal *= -1.0\\n\\n return (plane_normal, plane_origin)\",\n \"def create_plane(self):\\n\\n # First we calculate our point increment for both the x and y values\\n inc_x = (self.xmax - self.xmin)/(self.xlen - 1)\\n inc_y = (self.ymax - self.ymin)/(self.ylen - 1)\\n\\n # This for-loop will add every x-value with every y-value, saving the values column wise\\n # i.e. (-10,-10), (-10,-9), (-10.-8),...,(-10,n) for n = our y-values.\\n # store these combinations into a list, and add that to our plane. \\n # The nested loop will then traverse again and will get the combinations for the next x-value.\\n # The loop will continue until all x-values and y-value combinations are added to our plane.\\n for y in range(0, self.ylen + 1):\\n temp_list = []\\n for x in range(0, self.xlen + 1):\\n temp_list.append(self.f((self.xmin + x*inc_x) + (self.ymin + y*inc_y)*1j))\\n self.plane.append(temp_list)\",\n \"def invert_point_on_plane(point, plane):\\n _, _, proj = project_point_to_plane(point, plane)\\n\\n u, v = proj[0][1]\\n return u, v\",\n \"def SetNormal(self, *args):\\n return _itkSurfaceSpatialObjectPointPython.itkSurfaceSpatialObjectPoint2_SetNormal(self, *args)\",\n \"def test_point_on_plane(self, point, plane):\\n _dist = point.dot(plane[:3]) + plane[3]\\n if _dist <= epsilon:\\n print('OK => point on plane')\\n else:\\n print('NO => point not on plane')\",\n \"def mesh_slicer(self, plane, opt):\\n\\n # get plane coefficients\\n a = plane[0]\\n b = plane[1]\\n c = plane[2]\\n\\n # create vtk plane object\\n VTKplane = vtk.vtkPlane()\\n # for now we choose the center point as the point of rotation\\n VTKplane.SetOrigin(self.mesh_poly.GetCenter())\\n VTKplane.SetNormal(a, b, c)\\n VTKplane.SetOrigin(self.epi_apex_node)\\n\\n # create cutter\\n cutEdges = vtk.vtkCutter()\\n cutEdges.SetInputData(self.mesh_poly)\\n cutEdges.SetCutFunction(VTKplane)\\n cutEdges.GenerateCutScalarsOn()\\n cutEdges.SetValue(0, 0.5)\\n\\n # create renderer\\n ren = vtk.vtkRenderer()\\n ren.SetBackground(0.0, 0.0, 0.0)\\n\\n # create mapper\\n mapper = vtk.vtkPolyDataMapper()\\n mapper.SetInputConnection(cutEdges.GetOutputPort())\\n\\n # create actor\\n actor = vtk.vtkActor()\\n actor.SetMapper(mapper)\\n actor.GetProperty().SetColor(0.0, 0.0, 1.0)\\n actor.GetProperty().SetLineWidth(2)\\n\\n # display apex point\\n apexA = include_points(list(self.epi_apex_node), 1, 15, (0, 0, 1))\\n\\n if (opt == 'mesh'):\\n meshMapper = vtk.vtkPolyDataMapper()\\n meshMapper.SetInputData(self.mesh_poly)\\n meshActor = vtk.vtkActor()\\n meshActor.SetMapper(meshMapper)\\n meshActor.GetProperty().SetColor(1.0, 0.0, 0.0)\\n\\n # generate renderer\\n ren.AddActor(self.meshActor)\\n ren.AddActor(actor)\\n ren.AddActor(apexA)\\n\\n else:\\n ren.AddActor(actor)\\n ren.AddActor(apexA)\\n\\n # display\\n vtk_show(ren)\",\n \"def proj_to_plane(norm, d, pts):\\n a = norm[0]\\n b = norm[1]\\n c = norm[2]\\n\\n p = []\\n\\n for i in range(len(pts)):\\n x_p = pts[i][0]\\n y_p = pts[i][1]\\n z_p = pts[i][2]\\n\\n if a != 0:\\n x_0 = (b * b + c * c) * x_p - a * b * y_p - a * c * z_p - a * d\\n y_0 = (b * 1.0 / a) * (x_0 - x_p) + y_p\\n z_0 = (c * 1.0 / a) * (x_0 - x_p) + z_p\\n\\n elif b != 0:\\n x_0 = x_p \\n y_0 = c * c * y_p - b * (d + c)\\n z_0 = (c * 1.0 / b) *(y_0 - y_p) + z_p\\n\\n else:\\n x_0 = x_p\\n y_0 = y_p\\n z_0 = - d * 1.0 / c\\n\\n p.append([x_0, y_0, z_0])\\n \\n return p\",\n \"def proj_to_plane(norm, d, pts):\\n a = norm[0]\\n b = norm[1]\\n c = norm[2]\\n\\n p = []\\n\\n for i in range(len(pts)):\\n x_p = pts[i][0]\\n y_p = pts[i][1]\\n z_p = pts[i][2]\\n\\n if a != 0:\\n x_0 = (b * b + c * c) * x_p - a * b * y_p - a * c * z_p - a * d\\n y_0 = (b * 1.0 / a) * (x_0 - x_p) + y_p\\n z_0 = (c * 1.0 / a) * (x_0 - x_p) + z_p\\n\\n elif b != 0:\\n x_0 = x_p \\n y_0 = c * c * y_p - b * (d + c)\\n z_0 = (c * 1.0 / b) *(y_0 - y_p) + z_p\\n\\n else:\\n x_0 = x_p\\n y_0 = y_p\\n z_0 = - d * 1.0 / c\\n\\n p.append([x_0, y_0, z_0])\\n \\n return p\",\n \"def __init__(self, obj, plane):\\n self.obj = obj\\n self.plane = plane\\n self.plane_origin = plane[0]\\n self.plane_normal = plane[1]\\n self.distance_from_plane = np.dot((self.obj.vectors-self.plane[0]),\\n self.plane[1])\\n self.slice_points = []\\n\\n self.calculate_points()\\n \\n return None\",\n \"def _generate_random_points_in_plane(nvect, dparam, npts, eps=0.0):\\n np.random.seed(12345)\\n a, b, c = nvect / np.linalg.norm(nvect)\\n x, y = np.random.rand(npts), np.random.rand(npts)\\n z = (dparam - a * x - b * y) / c\\n if eps > 0:\\n z += np.random.normal(loc=0., scale=eps, size=npts)\\n return np.column_stack((x, y, z))\",\n \"def project_onto_plane(self,z):\\n U=self.U\\n Q=self.Q_p\\n #print(((z-Q[-2,:,[2]])/P[-2,:,[2]]).T)\\n #print(P[-2])\\n return ((z-Q[-2,:,[2]])/U[-2,:,[2]]).T*U[-2]+Q[-2]\",\n \"def plane_distance(p, plane):\\n x, y, z = p\\n A, B, C, D = plane\\n return A*x + B*y + C*z + D\",\n \"def surfcut_points(**kwargs):\\n npoints = kwargs.get( 'npoints', 240 )\\n origin = kwargs.get( 'origin', vec3(0.,0.,0.)) \\n normal = kwargs.get( 'normal', (np.pi/2., 0.) ) \\n lims0 = kwargs.get( 'lims0', (-50., 50.) ) \\n lims1 = kwargs.get( 'lims1', (-50., 50.) ) \\n extents = kwargs.get( 'extents', None) \\n \\n if extents is not None:\\n lims0 = (-extents, extents)\\n lims1 = (-extents, extents)\\n \\n # Make the unit vectors that define the plane\\n unit = vec3()\\n th = normal[0]\\n ph = normal[1]\\n unit.set_spherical( 1, th, ph) \\n orth0 = vec3( -1.*np.sin(ph), np.cos(ph), 0. )\\n orth1 = cross(unit,orth0)\\n \\n t0 = np.linspace( lims0[0], lims0[1], npoints )\\n t1 = np.linspace( lims1[0], lims1[1], npoints ) \\n \\n # Obtain points on which function will be evaluated\\n T0,T1 = np.meshgrid(t0,t1)\\n X = origin[0] + T0*orth0[0] + T1*orth1[0] \\n Y = origin[1] + T0*orth0[1] + T1*orth1[1]\\n Z = origin[2] + T0*orth0[2] + T1*orth1[2] \\n \\n\\n # If given an axes it will plot the reference surface to help visusalize\\n # the surface cut\\n \\n # Note that the axes needs to be created with a 3d projection. \\n # For example: \\n # fig = plt.figure( figsize=(4.,4.) ) \\n # gs = matplotlib.gridspec.GridSpec( 1,1 ) \\n # ax0 = fig.add_subplot( gs[0,0], projection='3d' ) \\n \\n ax0 = kwargs.get( 'ax0', None ) \\n if ax0 is not None: \\n\\n # Plot the reference surface\\n ax0.plot_surface(X, Y, Z, rstride=8, cstride=8, alpha=0.3, linewidth=0.)\\n ax0.set_xlabel('X')\\n ax0.set_ylabel('Y')\\n ax0.set_zlabel('Z')\\n lmin = min([ ax0.get_xlim()[0], ax0.get_ylim()[0], ax0.get_zlim()[0] ] )\\n lmax = max([ ax0.get_xlim()[1], ax0.get_ylim()[1], ax0.get_zlim()[1] ] )\\n ax0.set_xlim( lmin, lmax )\\n ax0.set_ylim( lmin, lmax )\\n ax0.set_zlim( lmin, lmax )\\n ax0.set_yticklabels([])\\n ax0.set_xticklabels([])\\n ax0.set_zticklabels([])\\n \\n # If given an axes and a potential it will plot the surface cut of the \\n # potential \\n\\n ax1 = kwargs.get( 'ax1', None) \\n pot = kwargs.get( 'potential', None) \\n\\n if (ax1 is not None) and (pot is not None):\\n # Evaluate function at points and plot\\n EVAL = pot.evalpotential(X,Y,Z)\\n\\n im =ax1.pcolormesh(T0, T1, EVAL, cmap = plt.get_cmap('jet')) \\n # cmaps: rainbow, jet\\n\\n plt.axes( ax1)\\n cbar = plt.colorbar(im)\\n cbar.set_label(pot.unitlabel, rotation=0 )#self.unitlabel\\n \\n return T0, T1, X, Y, Z\",\n \"def get_projection_point(self, point, plane, test=False):\\n return point_on_plane_projection(point, plane, test=test)\",\n \"def rotate_to_xz_plane(self, point):\\n if len(point) == 2:\\n x, z = point\\n else:\\n x, y, z = point\\n if y != 0.0:\\n x = np.sqrt(x**2 + y**2)\\n return abs(x), z\",\n \"def plane_from_multiple_points(pnts: Iterable[Point]) -> Plane:\\n n = len(pnts)\\n x = [pnt.x for pnt in pnts]\\n y = [pnt.y for pnt in pnts]\\n z = [pnt.z for pnt in pnts]\\n pntc = Point(sum(x)/n, sum(y)/n, sum(z)/n)\\n x = [pnt.x-pntc.x for pnt in pnts]\\n y = [pnt.y-pntc.y for pnt in pnts]\\n z = [pnt.z-pntc.z for pnt in pnts]\\n sxx = sum([x[i]**2 for i in range(n)])\\n sxy = sum([x[i]*y[i] for i in range(n)])\\n sxz = sum([x[i]*z[i] for i in range(n)])\\n syy = sum([y[i]**2 for i in range(n)])\\n syz = sum([y[i]*z[i] for i in range(n)])\\n d = sxx*syy-sxy**2\\n a = (syz*sxy-sxz*syy)/d\\n b = (sxy*sxz-sxx*syz)/d\\n nrm = Vector(a, b, 1.0)\\n return Plane(pntc, nrm)\",\n \"def from_3p(cls, a: Vector, b: Vector, c: Vector) -> 'Plane':\\n n = (b - a).cross(c - a).normalize()\\n return Plane(n, n.dot(a))\",\n \"def SetPlaneMode(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_ShapeConvertToBezier_SetPlaneMode(self, *args)\",\n \"def pointOnSurface(*args, caching: bool=True, constructionHistory: bool=True, nodeState:\\n Union[int, bool]=0, normal: bool=True, normalizedNormal: bool=True,\\n normalizedTangentU: bool=True, normalizedTangentV: bool=True, parameterU:\\n Union[float, bool]=0.0, parameterV: Union[float, bool]=0.0, position:\\n bool=True, tangentU: bool=True, tangentV: bool=True, turnOnPercentage:\\n bool=False, q=True, query=True, e=True, edit=True,\\n **kwargs)->Union[List[float3], Any]:\\n pass\",\n \"def PlaneNormalVector(h, k, l):\\r\\n vec = np.array([h, k, l])\\r\\n return vec/np.linalg.norm(vec)\",\n \"def fit_plane_to_point_cloud(pc: np.ndarray) -> Tuple[Any, Any, Any, Any]:\\n center = pc.sum(axis=0) / pc.shape[0]\\n u, s, vh = np.linalg.svd(pc - center)\\n\\n # Get the unitary normal vector\\n u_norm = vh[2, :]\\n d = -np.dot(u_norm, center)\\n a, b, c = u_norm\\n return a, b, c, d\",\n \"def plot_sag_plane(self, P0=None, sag_pl=None):\\n if P0 is None: P0 = np.array([0,0,0])\\n if sag_pl is None: sag_pl = self.sp\\n norm, d = sag_pl[:3], sag_pl[3]\\n import matplotlib.pyplot as plt\\n from mpl_toolkits.mplot3d import Axes3D\\n plt.ion()\\n # create x,y\\n xypts = 10\\n xrng = 300\\n yrng = 130\\n xrng_mesh = np.linspace(P0[0], P0[0]-xrng, xypts)\\n yrng_mesh = np.linspace(P0[1]-yrng/2., P0[1]+yrng, xypts)\\n xx, yy = np.meshgrid(xrng_mesh, yrng_mesh)\\n # calculate corresponding z\\n zz = -1 * (norm[0] * xx + norm[1] * yy + d) / norm[2]\\n # plot the surface\\n self.fig = plt.figure()\\n self.fig_ax = self.fig.add_subplot(111, projection='3d')\\n self.fig_ax.plot_wireframe(xx, yy, zz, color='gray')\\n #ax.quiver(P0[0], P0[1], norm[0], norm[1])\\n self.fig_ax.set_xlabel('X')\\n self.fig_ax.set_ylabel('Y')\\n self.fig_ax.set_zlabel('Z')\\n self.fig_ax.set_zlim(P0[2]-xrng, P0[2]+yrng)\\n plt.show()\",\n \"def project_point(self, point: array_like) -> Point:\\n # Vector from the point in space to the point on the plane.\\n vector_to_plane = Vector.from_points(point, self.point)\\n\\n # Perpendicular vector from the point in space to the plane.\\n vector_projected = self.normal.project_vector(vector_to_plane)\\n\\n return Point(point) + vector_projected\",\n \"def polyPlane(*args, axis: Union[List[float, float, float], bool]=None, createUVs: Union[int,\\n bool]=1, height: Union[float, bool]=1.0, subdivisionsHeight: Union[int, bool]=0,\\n subdivisionsWidth: Union[int, bool]=10, subdivisionsX: Union[int, bool]=5,\\n subdivisionsY: Union[int, bool]=5, texture: Union[int, bool]=1, width:\\n Union[float, bool]=1.0, caching: bool=True, constructionHistory: bool=True, name:\\n AnyStr=\\\"\\\", nodeState: Union[int, bool]=0, object: bool=True, q=True, query=True,\\n e=True, edit=True, **kwargs)->Union[List[AnyStr], Any]:\\n pass\",\n \"def normal(self, point):\\n return self._normal.dup()\",\n \"def distance_point_plane(point, plane):\\n base, normal = plane\\n vector = subtract_vectors(point, base)\\n return fabs(dot_vectors(vector, normal))\",\n \"def test_surface_normal(self):\\n vertices = np.array([[0, 1, 0], [0, 0, 0], [1, 0, 0]])\\n expected = np.array([0, 0, 1])\\n np.testing.assert_almost_equal(surface_normal(vertices), expected)\\n\\n # Test against multiple triangles\\n vertices = np.r_[vertices[np.newaxis, :, :], [[[0, 0, 0], [0, 2, 0], [2, 0, 0]]]]\\n expected = np.array([[0, 0, 1], [0, 0, -1]])\\n np.testing.assert_almost_equal(surface_normal(vertices), expected)\\n\\n # Some real data\\n vertices = np.array([[2.435, -1.82, -0.53], [2.635, -2., -0.58], [2.535, -1.7, -0.58]])\\n expected = np.array([0.33424239, 0.11141413, 0.93587869])\\n np.testing.assert_almost_equal(surface_normal(vertices), expected)\\n\\n # Test input validation\\n self.assertRaises(ValueError, surface_normal, np.array([[1, 2, 3, 4]]))\",\n \"def make_inward_normal(tetrahedron):\\n\\n convert_to_np_array = lambda v: np.array([v.x, v.y, v.z])\\n np_vertices = list(map(convert_to_np_array, [tetrahedron.get_vertex(i) for i in range(4)]))\\n # This is the middle point\\n # midpoint = np.mean(np_vertices, axis=0)\\n\\n midpoint = np_vertices[0]\\n for i in range(1, 4):\\n midpoint += np_vertices[i]\\n midpoint = midpoint / 2.0\\n\\n for i in range(4):\\n face = tetrahedron.get_face(i)\\n d = distance(face, midpoint)\\n if d < 0:\\n face.nx *= -1.0\\n face.ny *= -1.0\\n face.nz *= -1.0\\n face.d *= -1.0\",\n \"def project_3d_points_to_plane(points, p1, p2 ,p3, numpoints):\\n p1 = np.asarray(p1)\\n p2 = np.asarray(p2)\\n p3 = np.asarray(p3)\\n\\n # get vectors in plane\\n v1 = p3 - p1\\n v2 = p2 - p1\\n\\n # compute cross product\\n cp = np.cross(v1, v2)\\n a, b, c = cp # normal to plane is ax + by + cz\\n\\n # evaluate d\\n d = np.dot(cp, p3)\\n\\n # thus, normal is given by\\n plane = vtk.vtkPlane()\\n origin = p1\\n normal = normalize(np.array([a,b,c]))\\n plane.SetOrigin(p1)\\n plane.SetNormal(normal)\\n\\n if numpoints == 1:\\n proj = [0,0,0]\\n plane.ProjectPoint(points, origin, normal, proj)\\n return proj\\n else:\\n projected_pts = np.zeros((numpoints, 3), dtype=float)\\n\\n for i in range(numpoints):\\n proj = [0,0,0]\\n plane.ProjectPoint(points[i], origin, normal, proj)\\n projected_pts[i] = proj\\n\\n return projected_pts\",\n \"def get_normal_vector_of_plane(p1, p2, p3):\\n v12 = np.array(p1) - np.array(p2)\\n v13 = np.array(p1) - np.array(p3)\\n nvec = np.cross(v12, v13)\\n ## print 'norm: '+str(np.linalg.norm(nvec))\\n return nvec / np.linalg.norm(nvec)\",\n \"def get_plane(self, scalar, plane, pval):\\n\\n if plane == 'yz' or plane == 'zy':\\n # z along rows, y along columns\\n return scalar[:, pval, :]\\n elif plane == 'xz' or plane == 'zx':\\n # x along columns, z along rows\\n return scalar[:, :, pval]\\n elif plane == 'xy' or plane == 'yx':\\n # x along rows, y along columns\\n return scalar[pval, :, :]\",\n \"def plane_sphere(p, s):\\n\\n p.normalize()\\n\\n d = dot(s.o-p.o, p.n)\\n\\n if d > s.r:\\n return False\\n else:\\n return (s.o - d*p.n, sqrt(s.r*s.r - d*d))\",\n \"def ProjectToPlane(self):\\n\\n self.__do_essential_memebers_exist__()\\n if self.element_type != \\\"tri\\\":\\n raise ValueError(\\\"Project to plane is only applicable to triangles\\\")\\n\\n imesh = deepcopy(self)\\n coordinates = []\\n connectivities = []\\n for counter, elem in enumerate(imesh.elements):\\n\\n elementCoordinates = imesh.points[elem,:]\\n\\n A = elementCoordinates[0,:]\\n B = elementCoordinates[1,:]\\n C = elementCoordinates[2,:]\\n\\n X = (B - A); X /= np.linalg.norm(X)\\n Z = np.cross(X, C - A); Z /= np.linalg.norm(Z)\\n Y = np.cross(Z, X)\\n\\n # PROJECT THE TRIANGLE TO THIS BASES\\n a = [0., 0.]\\n b = [np.linalg.norm((B - A)), 0.]\\n c = [(C - A).dot(X), (C - A).dot(Y)]\\n\\n coordinates.append(a)\\n coordinates.append(b)\\n coordinates.append(c)\\n\\n elementConnectivity = [3 * counter, 3 * counter + 1, 3 * counter + 2]\\n connectivities.append(elementConnectivity)\\n\\n coordinates = np.array(coordinates)\\n connectivities = np.array(connectivities)\\n imesh.points = coordinates\\n imesh.elements = connectivities\\n imesh.nelem = imesh.elements.shape[0]\\n imesh.nnode = imesh.points.shape[0]\\n\\n return imesh\",\n \"def __copy__(self) -> 'Plane':\\n return self.__class__(self._normal, self._distance_from_origin)\",\n \"def normal(self) -> Vec:\\n # The three points are in clockwise order, so compute differences\\n # in the clockwise direction, then cross to get the normal.\\n point_1 = self.planes[1] - self.planes[0]\\n point_2 = self.planes[2] - self.planes[1]\\n\\n return Vec.cross(point_1, point_2).norm()\",\n \"def add_planet(self,x,y,z):\\n\\t\\tself.ob.append(vis.sphere(x=x, y=y, z=z, radius = 0.1))\",\n \"def WritePlane(self):\\n if not self.__train:\\n print('ERROR: Must use Train before WritePlane')\\n sys.exit(-1)\\n if not self.__openPlaneO:\\n print('ERROR: Must use OpenPlaneO before WritePlane')\\n sys.exit(-1)\\n\\n # Defines angular dimensions\\n self.__nc_RSoft_O.createDimension('type', self.__n_type)\\n\\n # Defines variables\\n if self.__containsRadial:\\n rad_plane_id = self.__nc_RSoft_O.createVariable(\\\\\\n 'radial_plane', 'f4', \\\\\\n ('type','radial_structure_functions'))\\n rad_plane_id[:] = self.radial_plane\\n if self.__containsAngular:\\n ang_plane_id = self.__nc_RSoft_O.createVariable(\\\\\\n 'angular_plane', 'f4', \\\\\\n ('type','angular_structure_functions'))\\n ang_plane_id[:] = self.angular_plane\\n intercept_id_O = self.__nc_RSoft_O.createVariable(\\\\\\n 'intercept', 'f4', ('type'))\\n intercept_id_O[:] = self.intercept\",\n \"def normal(self, point):\\n point = self._center - np.array(point)\\n # if abs(point.dot(point) - self._radius**2) > 1e-15:\\n # raise RayTraceError(\\n # 'Cannot compute normal. Point is too far from surface ({}).'.format(\\n # (abs(point.dot(point) - self._radius**2))))\\n return normalize(point / self._radius)\",\n \"def surface_norm(self, pt):\\n\\n return self.normal.normalize()\",\n \"def normal(axis_direction, axis_origin, point):\\n # transform input into numpy arrays\\n axis_direction = np.array(axis_direction, float)\\n axis_origin = np.array(axis_origin, float)\\n point = np.array(point, float)\\n\\n # vector from axis normal_origin to point\\n vector = point - axis_origin\\n\\n # projection of vector on axis\\n projection = np.dot(vector, axis_direction)*axis_direction\\n\\n # the normal vector from normal_origin to point\\n normal_direction = vector - projection\\n\\n # normalized normal_direction\\n normal_direction = normal_direction/np.linalg.norm(normal_direction)\\n\\n # opposite of the projection of vector on normal\\n projection2 = - np.dot(normal_direction, vector)*normal_direction\\n\\n normal_origin = point + projection2\\n\\n return normal_direction, normal_origin\",\n \"def __init__(self,\\n r = 1.0,\\n normal = Vector(0.0,1.0,0.0),\\n origin = Vector(0.0,0.0,0.0),\\n orientation = Vector(1.0,0.0,0.0),\\n c1 = Color(0.01,0.01,0.01),\\n c2 = Color(0.99,0.99,0.99)):\\n \\n CheckPlane.__init__(self, normal, origin, orientation, c1, c2)\\n self.origin = origin\\n self.set_orientation(orientation)\\n self.r = r\\n self.R = r ** 2.0\",\n \"def plane_from_points(a, b, c):\\n ab = subtract_vectors(b, a)\\n ac = subtract_vectors(c, a)\\n n = normalize_vector(cross_vectors(ab, ac))\\n return a, n\",\n \"def sample(self, z_position):\\n if self.direction[2] != 0:\\n z_plane = PlaneSurface([0, 0, 1], [0, 0, z_position])\\n if (z_plane.position() - self.position).dot(self.direction) > 0:\\n ray = self\\n else:\\n ray = Ray(-self.direction, self.position)\\n return ray.propagate(z_plane.time_to_bound(ray)).position\",\n \"def xzplane(draw, r, y, shift = np.array([1000, 1000, 0, 0]), scale = 300):\\n extent = 2.8\\n pln = np.array(\\n [\\n [-extent,y,0],\\n [extent,y,0],\\n [extent,y,extent*2],\\n [-extent,y,extent*2]\\n ]\\n )\\n pln = np.dot(pln, np.transpose(r))\\n pln = pln * scale + shift[:3]\\n draw.polygon([(pln[0][0],pln[0][1]),(pln[1][0],pln[1][1]),(pln[2][0],pln[2][1]),(pln[3][0],pln[3][1])], (0,102,255,70))\",\n \"def invert_plane_stress(normal, slip, weights=None):\\n nx, ny, nz = normal\\n sx, sy, sz = slip\\n\\n Gx = np.zeros((nx.size, 3))\\n Gx[:,0] = nx - nx**3 + nx*nz**2 \\n Gx[:,1] = ny - 2*ny*nx**2\\n Gx[:,2] = -nx*ny**2 + nx*nz**2\\n \\n Gy = np.zeros((nx.size, 3))\\n Gy[:,0] = -ny*nx**2 + ny*nz**2\\n Gy[:,1] = nx - 2*nx*ny**2\\n Gy[:,2] = ny - ny**3 + ny*nz**2\\n \\n Gz = np.zeros((nx.size, 3))\\n Gz[:,0] = -nz*nx**2 - nz + nz**3\\n Gz[:,1] = -2*nx*ny*nz\\n Gz[:,2] = -ny**2*nz - nz + nz**3\\n\\n\\n G = np.vstack((Gx, Gy, Gz)).T\\n d = np.hstack([sx,sy,sz])\\n\\n if weights is not None:\\n weights = np.tile(weights, 3)\\n G *= weights\\n d *= weights\\n\\n m, residual, rank, sing_vals = np.linalg.lstsq(G.T,d.T)\\n\\n s11, s12, s22 = m\\n s33 = -(s11 + s22)\\n\\n sigma = np.array([[s11, s12, 0.0],\\n [s12, s22, 0.0],\\n [0.0, 0.0, s33]])\\n return sigma\",\n \"def normal_at(self, world_point: Point) -> Vector:\\n # Convert the world point and normal to shape space\\n local_point = self.world_to_object(world_point)\\n # Calculate the normal in shape space\\n local_normal = self.local_normal_at(local_point)\\n # Convert the local normal vector back to world space\\n return self.normal_to_world(local_normal)\",\n \"def plane_equation(p1, p2, p3):\\n a1 = p2[0] - p1[0]\\n b1 = p2[1] - p1[1]\\n c1 = p2[2] - p1[2]\\n a2 = p3[0] - p1[0]\\n b2 = p3[1] - p1[1]\\n c2 = p3[2] - p1[2]\\n a = b1 * c2 - b2 * c1\\n b = a2 * c1 - a1 * c2\\n c = a1 * b2 - b1 * a2\\n # Points are collinear\\n if (abs(a) < 1e-6) and (abs(b) < 1e-6) and (abs(c) < 1e-6):\\n return None\\n # All clear\\n d = (- a * p1[0] - b * p1[1] - c * p1[2])\\n return a, b, c, d\",\n \"def from_vector(cls, vector) -> 'Plane':\\n v = Vector(vector)\\n return Plane(v.normalize(), v.magnitude)\",\n \"def planes_3d(self, quantity, xplane, yplane):\\n xplane = int(xplane)\\n yplane = int(yplane)\\n # Get the scalar values\\n # Get the data on the plane with a fixed x value. These means we'll\\n # have changing (y, z) points\\n xdata = self.get_plane(quantity, 'yz', xplane)\\n # z first cuz we want y to be changing before z to correspond with the\\n # way numpy flattens arrays. Note this means y points will be in the\\n # 2nd column\\n xplanepoints = np.array(list(itertools.product(self.Z, self.Y)))\\n xdata = xdata.flatten()\\n xplanexval = np.array(list(itertools.repeat(x[xplane], len(xdata))))\\n xplanedata = np.zeros((xplanepoints.shape[0], 4))\\n xplanedata[:, 0] = xplanexval\\n xplanedata[:, 1] = xplanepoints[:, 1]\\n xplanedata[:, 2] = xplanepoints[:, 0]\\n xplanedata[:, 3] = xdata\\n # Same procedure for fixed y plane\\n ydata = self.get_plane(quantity, 'xz', yplane)\\n yplanepoints = np.array(list(itertools.product(z, x)))\\n ydata = ydata.flatten()\\n yplaneyval = np.array(list(itertools.repeat(y[yplane], len(ydata))))\\n yplanedata = np.zeros((yplanepoints.shape[0], 4))\\n yplanedata[:, 0] = yplanepoints[:, 1]\\n yplanedata[:, 1] = yplaneyval\\n yplanedata[:, 2] = yplanepoints[:, 0]\\n yplanedata[:, 3] = ydata\\n labels = ('X [um]', 'Y [um]', 'Z [um]', quantity)\\n # Now stack them vertically and plot!\\n all_data = np.vstack((xplanedata, yplanedata))\\n self.scatter3d(all_data[:, 0], all_data[:, 1], all_data[:, 2],\\n all_data[:, 3], labels, 'planes_3d')\",\n \"def build_coord(norm, d, pts):\\n # Compute the origin as the mean point of the points, and this point has to be on the plane\\n \\n n = len(pts) \\n x_total = 0\\n y_total = 0\\n z_total = 0\\n \\n for i in range(n):\\n x_total += pts[i][0]\\n y_total += pts[i][1]\\n z_total += pts[i][2]\\n\\n x_o = x_total * 1.0 / n\\n y_o = y_total * 1.0 / n\\n z_o = z_total * 1.0 / n\\n p_o = [x_o, y_o, z_o]\\n \\n # Choose p be the projection of a vector in the z-axis to the plane\\n # If the plane is not perpendicular to the z-axis\\n if ((norm[2] != 1) and (norm[2] != -1)): \\n # Choose a point\\n o_z = [x_o, y_o, z_o + 1]\\n \\n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\\n \\n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\\n\\n x_c = (x_p - x_o) * 1.0 / dist \\n y_c = (y_p - y_o) * 1.0 / dist\\n z_c = (z_p - z_o) * 1.0 / dist\\n # Thus we have unit vector in x direction\\n e_y = [x_c, y_c, z_c]\\n #Compute the unit vector in y direction\\n e_x = np.cross(e_y, norm).tolist()\\n else:\\n e_x = [1, 0, 0]\\n e_y = [0, 1, 0]\\n \\n return [e_x, e_y, norm] , p_o\",\n \"def planarize(self):\\r\\n from lsst.analysis import utils\\r\\n assert numpy.isfinite(self.z).all()\\r\\n self.z -= utils.evalplane(self.plane(), self.points)\",\n \"def plot_surface(self):\\n X, Y = np.meshgrid(self.x, self.y)\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n ax.plot_surface(X=X, Y=Y, Z=self.z)\\n plt.show()\",\n \"def build_coord(norm, d, pts):\\n # Compute the origin as the mean point of the points, and this point has to be on the plane\\n \\n n = len(pts)\\n x_total = 0\\n y_total = 0\\n z_total = 0\\n \\n for i in range(n):\\n x_total += pts[i][0]\\n y_total += pts[i][1]\\n z_total += pts[i][2]\\n\\n x_o = x_total * 1.0 / n\\n y_o = y_total * 1.0 / n\\n z_o = z_total * 1.0 / n\\n p_o = [x_o, y_o, z_o]\\n \\n # Choose p be the projection of a vector in the z-axis to the plane\\n # If the plane is not perpendicular to the z-axis\\n if ((norm[2] != 1) and (norm[2] != -1)): \\n # Choose a point\\n o_z = [x_o, y_o, z_o + 1]\\n \\n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\\n \\n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\\n\\n x_c = (x_p - x_o) * 1.0 / dist \\n y_c = (y_p - y_o) * 1.0 / dist\\n z_c = (z_p - z_o) * 1.0 / dist\\n # Thus we have unit vector in x direction\\n e_y = [x_c, y_c, z_c]\\n #Compute the unit vector in y direction\\n e_x = np.cross(e_y, norm).tolist()\\n else:\\n e_x = [1, 0, 0]\\n e_y = [0, 1, 0]\\n \\n return [e_x, e_y, norm] , p_o\",\n \"def project_points_plane(points, plane):\\n return [project_point_plane(point, plane) for point in points]\",\n \"def plot_projection(self, normal=(1, 1, 1), index_row=0, index_col=0, show=True, texture=None, cmap=\\\"jet\\\", f=None,\\n plotter=None, title='', font_size=10, font_color='black'):\\n if not plotter:\\n plotter = pv.Plotter()\\n plotter.subplot(index_column=index_col, index_row=index_row)\\n\\n plotter.add_text(title, position=\\\"upper_edge\\\", font_size=font_size, color=font_color)\\n tex = None\\n if texture:\\n\\n if isinstance(texture, np.ndarray):\\n tex = pv.numpy_to_texture(texture)\\n else:\\n tex = pv.read_texture(texture)\\n self.pv_mesh.texture_map_to_plane(inplace=True)\\n # plotter.add_mesh(pv_mesh, texture=tex)\\n\\n og = self.pv_mesh.center\\n projected = self.pv_mesh.project_points_to_plane(origin=og, normal=normal)\\n projected.texture_map_to_plane()\\n plotter.add_mesh(projected, texture=tex)\\n if show:\\n plotter.show()\\n return plotter\",\n \"def drawVector3D(x0,y0,z0,x1,y1,z1, vtype='normal'):\\n dislin.vectr3(x0,y0,z0,x1,y1,z1, vectordict[vtype])\",\n \"def surfaceRender(nodal_mesh, focus, ax=None):\\n\\t# If no axes were passed, generate new set of axes\\n\\tif not ax:\\n\\t\\tfig = mplt.figure()\\n\\t\\tax = fig.add_subplot(111, projection='3d')\\n\\n\\t# Sort the mesh by first 3 columns\\n\\tnodal_mesh = nodal_mesh[nodal_mesh[:, 0].argsort()]\\n\\tnodal_mesh = nodal_mesh[nodal_mesh[:, 1].argsort(kind='mergesort')]\\n\\tnodal_mesh = nodal_mesh[nodal_mesh[:, 2].argsort(kind='mergesort')]\\n\\t\\n\\t# Set up number of divisions and calculate e for each division (as a ratio)\\n\\tnum_div = 20\\n\\te = [i/num_div for i in range(num_div + 1)]\\n\\t# Convert angular values from degrees to radians\\n\\trads = math.pi/180\\n\\tnodal_mesh[:, 1:3] *= rads\\n\\t# Store the shapes and sizes of the mesh values\\n\\tm = nodal_mesh.shape[0]\\n\\tsize_nodal_nu = np.where(nodal_mesh[:, 2] == 0)[0].size\\n\\tsize_nodal_phi = m/size_nodal_nu\\n\\t# Get the mu and theta values from the mesh\\n\\tnodal_nu = nodal_mesh[:size_nodal_nu, 1]\\n\\tnodal_phi = nodal_mesh[::size_nodal_nu, 2]\\n\\t# Convert apex node from prolate to cartesian, then plot with scatter\\n\\tif min(nodal_nu) == 0:\\n\\t\\tx, y, z = mathhelper.prolate2cart(nodal_mesh[0, 0], nodal_mesh[0, 1], nodal_mesh[0, 2], focus)\\n\\t\\tax.scatter(z, y, -x)\\n\\t\\tstart_nu = 1\\n\\telse:\\n\\t\\tstart_nu = 0\\n\\t# Plot circumferential element boundaries\\n\\tfor i in range(start_nu, size_nodal_nu):\\n\\t\\tfor j in range(int(size_nodal_phi)):\\n\\t\\t\\t# Define nodal values for interpolation\\n\\t\\t\\tif j == size_nodal_phi-1:\\n\\t\\t\\t\\tind0 = i\\n\\t\\t\\t\\tp0 = 2*math.pi\\n\\t\\t\\telse:\\n\\t\\t\\t\\tind0 = (j+1)*size_nodal_nu + i\\n\\t\\t\\t\\tp0 = nodal_phi[j+1]\\n\\t\\t\\tind1 = (j)*size_nodal_nu + i\\n\\t\\t\\tp1 = nodal_phi[j]\\n\\t\\t\\t# Get mu and dM/dm1\\n\\t\\t\\tm0 = nodal_mesh[ind0, 0]\\n\\t\\t\\tdm0 = nodal_mesh[ind0, 3]\\n\\t\\t\\tm1 = nodal_mesh[ind1, 0]\\n\\t\\t\\tdm1 = nodal_mesh[ind1, 3]\\n\\t\\t\\t# Convert to cartesian\\n\\t\\t\\tn0x, n0y, n0z = mathhelper.prolate2cart(nodal_mesh[ind0, 0], nodal_mesh[ind0, 1], nodal_mesh[ind0, 2], focus)\\n\\t\\t\\t# Plot the node\\n\\t\\t\\tax.scatter(n0z, n0y, -n0x)\\n\\t\\t\\t# Plot the arc segments\\n\\t\\t\\tfor k in range(2, len(e)):\\n\\t\\t\\t\\t# Determine starting point to use\\n\\t\\t\\t\\tif k == 2:\\n\\t\\t\\t\\t\\tpt_x, pt_y, pt_z = n0x, n0y, n0z\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tpt_x, pt_y, pt_z = x_here, y_here, z_here\\n\\t\\t\\t\\t# Get lambda\\n\\t\\t\\t\\thm0 = 1 - 3*(e[k]**2) + 2*(e[k]**3)\\n\\t\\t\\t\\thdm0 = e[k]*(e[k] - 1)**2\\n\\t\\t\\t\\thm1 = (e[k]**2)*(3 - 2*e[k])\\n\\t\\t\\t\\thdm1 = (e[k]**2)*(e[k] - 1)\\n\\t\\t\\t\\tm = hm0 * m0 + hdm0 * dm0 + hm1 * m1 + hdm1 * dm1\\n\\t\\t\\t\\t# Get theta\\n\\t\\t\\t\\tp_here = p0 - e[k]*(p0 - p1)\\n\\t\\t\\t\\t# Convert to cartesian\\n\\t\\t\\t\\tx_here, y_here, z_here = mathhelper.prolate2cart(m, nodal_nu[i], p_here, focus)\\n\\t\\t\\t\\t# Create vectors\\n\\t\\t\\t\\tx = np.append(pt_x, x_here)\\n\\t\\t\\t\\ty = np.append(pt_y, y_here)\\n\\t\\t\\t\\tz = np.append(pt_z, z_here)\\n\\t\\t\\t\\t# Plot segments\\n\\t\\t\\t\\tax.plot(z, y, -x, 'k-.')\\n\\t# Plot longitudinal element boundaries\\n\\tfor i in range(int(size_nodal_phi)):\\n\\t\\tfor j in range(size_nodal_nu-1):\\n\\t\\t\\t# Define nodal values needeed for interpolation\\n\\t\\t\\tind0 = i*size_nodal_nu + j\\n\\t\\t\\tind1 = ind0 + 1\\n\\t\\t\\tn0 = nodal_nu[j]\\n\\t\\t\\tn1 = nodal_nu[j+1]\\n\\t\\t\\t# Get lambda and dL/de2\\n\\t\\t\\tm0 = nodal_mesh[ind0, 0]\\n\\t\\t\\tdm0 = nodal_mesh[ind0, 4]\\n\\t\\t\\tm1 = nodal_mesh[ind1, 0]\\n\\t\\t\\tdm1 = nodal_mesh[ind1, 4]\\n\\t\\t\\t# Convert nodal points to cartesian\\n\\t\\t\\tn0x, n0y, n0z = mathhelper.prolate2cart(nodal_mesh[ind0, 0], nodal_mesh[ind0, 1], nodal_mesh[ind0, 2], focus)\\n\\t\\t\\t# Plot arc\\n\\t\\t\\tfor k in range(2, len(e)):\\n\\t\\t\\t\\t# Determine point to use\\n\\t\\t\\t\\tif k == 2:\\n\\t\\t\\t\\t\\tpt_x, pt_y, pt_z = n0x, n0y, n0z\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tpt_x, pt_y, pt_z = x_here, y_here, z_here\\n\\t\\t\\t\\t# Get lambda\\n\\t\\t\\t\\thm0 = 1 - 3*(e[k]**2) + 2*(e[k]**3)\\n\\t\\t\\t\\thdm0 = e[k]*(e[k] - 1)**2\\n\\t\\t\\t\\thm1 = (e[k]**2)*(3 - 2*e[k])\\n\\t\\t\\t\\thdm1 = (e[k]**2)*(e[k] - 1)\\n\\t\\t\\t\\tm = hm0 * m0 + hdm0 * dm0 + hm1 * m1 + hdm1 * dm1\\n\\t\\t\\t\\t# Get nu\\n\\t\\t\\t\\tn_here = n0 + e[k]*(n1-n0)\\n\\t\\t\\t\\t# Convert to cartesian\\n\\t\\t\\t\\tx_here, y_here, z_here = mathhelper.prolate2cart(m, n_here, nodal_phi[i], focus)\\n\\t\\t\\t\\t# Append the vectors for plotting\\n\\t\\t\\t\\tx = np.append(pt_x, x_here)\\n\\t\\t\\t\\ty = np.append(pt_y, y_here)\\n\\t\\t\\t\\tz = np.append(pt_z, z_here)\\n\\t\\t\\t\\t# Plot the segment\\n\\t\\t\\t\\tax.plot(z, y, -x, 'k-.')\\n\\t\\t\\t\\t\\n\\treturn(ax)\",\n \"def random_plane_points(num_points, bounds):\\n\\n # Infer dimension of data from bounds\\n (bounds, dimension) = infer_dimension(bounds)\\n\\n # Generate points and rescale to fit bounds\\n points = np.random.rand(num_points, dimension)\\n unit_mean = [0.5] * dimension\\n shifted_points = points - unit_mean + bounds.mean(axis=1)\\n scale = bounds[:, 1] - bounds[:, 0]\\n rescaled_points = np.dot(shifted_points, np.diag(scale))\\n\\n return rescaled_points\",\n \"def plane_2d(self, quantity, plane, pval, draw=False, fixed=None):\\n self.log.info('Plotting plane')\\n pval = int(pval)\\n # x = np.arange(0, self.period, self.dx)\\n # y = np.arange(0, self.period, self.dy)\\n # z = np.arange(0, self.height + self.dz, self.dz)\\n x = self.X\\n y = self.Y\\n z = self.Z\\n # Get the scalar values\\n freq = self.conf['Simulation']['params']['frequency']\\n wvlgth = (consts.c / freq) * 1E9\\n title = 'Frequency = {:.4E} Hz, Wavelength = {:.2f} nm'.format(\\n freq, wvlgth)\\n # Get the plane we wish to plot\\n cs = self.get_plane(quantity, plane, pval)\\n self.log.info('DATA SHAPE: %s' % str(cs.shape))\\n show = self.conf['General']['show_plots']\\n p = False\\n sim_dir = os.path.expandvars(self.conf['General']['sim_dir'])\\n if plane == 'yz' or plane == 'zy':\\n labels = ('y [um]', 'z [um]', quantity, title)\\n if self.conf['General']['save_plots']:\\n p = os.path.join(sim_dir,\\n '%s_plane_2d_yz_pval%s.png' % (quantity,\\n str(pval)))\\n self.heatmap2d(y, z, cs, labels, plane, pval,\\n save_path=p, show=show, draw=draw, fixed=fixed)\\n elif plane == 'xz' or plane == 'zx':\\n labels = ('x [um]', 'z [um]', quantity, title)\\n if self.conf['General']['save_plots']:\\n p = os.path.join(sim_dir,\\n '%s_plane_2d_xz_pval%s.png' % (quantity,\\n str(pval)))\\n self.heatmap2d(x, z, cs, labels, plane, pval,\\n save_path=p, show=show, draw=draw, fixed=fixed)\\n elif plane == 'xy' or plane == 'yx':\\n labels = ('y [um]', 'x [um]', quantity, title)\\n if self.conf['General']['save_plots']:\\n p = os.path.join(sim_dir,\\n '%s_plane_2d_xy_pval%s.png' % (quantity,\\n str(pval)))\\n self.heatmap2d(x, y, cs, labels, plane, pval,\\n save_path=p, show=show, draw=draw, fixed=fixed)\",\n \"def get_transformable_plane(self, x_range = None, y_range = None):\\n plane_config = dict(self.plane_config)\\n shift_val = ORIGIN\\n if x_range is not None:\\n x_min, x_max = x_range\\n plane_config[\\\"x_radius\\\"] = x_max - x_min\\n shift_val += (x_max+x_min)*RIGHT/2.\\n if y_range is not None:\\n y_min, y_max = y_range\\n plane_config[\\\"y_radius\\\"] = y_max - y_min\\n shift_val += (y_max+y_min)*UP/2.\\n plane = ComplexPlane(**plane_config)\\n plane.shift(shift_val)\\n if self.use_multicolored_plane:\\n self.paint_plane(plane)\\n return plane\",\n \"def from_vectors(cls, point: array_like, vector_a: array_like, vector_b: array_like, **kwargs) -> Plane:\\n vector_a = Vector(vector_a)\\n\\n if vector_a.is_parallel(vector_b, **kwargs):\\n raise ValueError(\\\"The vectors must not be parallel.\\\")\\n\\n # The cross product returns a 3D vector.\\n vector_normal = vector_a.cross(vector_b)\\n\\n # Convert the point to 3D so that it matches the vector dimension.\\n point = Point(point).set_dimension(3)\\n\\n return cls(point, vector_normal)\",\n \"def boom_plane(self):\\n return Plane(reference=self.tail_shaft_circle[0].center,\\n normal=Vector(0, 1, 0),\\n binormal=Vector(0, 0, 1))\",\n \"def normal(self, t=0):\\n n = Line3d()\\n n.p = self.lerp(t)\\n n.v = self.cross\\n return n\",\n \"def xyplane(draw, r, x, shift = np.array([1000, 1000, 0, 0]), scale = 300):\\n extent = 2.8\\n pln = np.array(\\n [\\n [x,-extent,0],\\n [x,extent,0],\\n [x,extent,extent*2],\\n [x,-extent,extent*2]\\n ]\\n )\\n pln = np.dot(pln,np.transpose(r))\\n pln = pln * scale + shift[:3]\\n draw.polygon([(pln[0][0],pln[0][1]),(pln[1][0],pln[1][1]),(pln[2][0],pln[2][1]),(pln[3][0],pln[3][1])], (0,102,255,70))\",\n \"def plane_point_side_v3(p: np.ndarray, v: np.ndarray) -> Any:\\n return p[:3].dot(v) + p[3]\",\n \"def intersect_plane(self, other: Plane, **kwargs) -> Line:\\n if self.normal.is_parallel(other.normal, **kwargs):\\n raise ValueError(\\\"The planes must not be parallel.\\\")\\n\\n array_normals_stacked = np.vstack((self.normal, other.normal))\\n\\n # Construct a matrix for a linear system.\\n array_00 = 2 * np.eye(3)\\n array_01 = array_normals_stacked.T\\n array_10 = array_normals_stacked\\n array_11 = np.zeros((2, 2))\\n matrix = np.block([[array_00, array_01], [array_10, array_11]])\\n\\n dot_a = np.dot(self.point, self.normal)\\n dot_b = np.dot(other.point, other.normal)\\n array_y = np.array([0, 0, 0, dot_a, dot_b])\\n\\n # Solve the linear system.\\n solution = np.linalg.solve(matrix, array_y)\\n\\n point_line = Point(solution[:3])\\n direction_line = self.normal.cross(other.normal)\\n\\n return Line(point_line, direction_line)\",\n \"def get_plane(self, quantity, plane, pval):\\n\\n self.log.info('Retrieving plane for %s', quantity)\\n scalar = self.get_scalar_quantity(quantity)\\n if plane == 'yz' or plane == 'zy':\\n # z along rows, y along columns\\n return scalar[:, pval, :]\\n elif plane == 'xz' or plane == 'zx':\\n # x along columns, z along rows\\n return scalar[:, :, pval]\\n elif plane == 'xy' or plane == 'yx':\\n # x along rows, y along columns\\n return scalar[pval, :, :]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6926132","0.67918247","0.66280645","0.6622853","0.6570255","0.6499382","0.64442146","0.6332076","0.62797856","0.62646264","0.6246257","0.6151091","0.6120761","0.6096576","0.60693115","0.59628874","0.5912617","0.58920056","0.58715844","0.585937","0.58575803","0.58491397","0.5846112","0.5843997","0.58173543","0.5813309","0.57830566","0.57630634","0.5756629","0.57460064","0.5741681","0.57187223","0.57041","0.5703605","0.56917787","0.56906664","0.5686903","0.567886","0.5677912","0.5674802","0.5674802","0.5671491","0.56708795","0.56696886","0.56674445","0.56576335","0.5630148","0.562735","0.5625279","0.5614196","0.56068265","0.55967784","0.55874074","0.55793387","0.55628","0.55516875","0.5541118","0.55336416","0.5523495","0.55062515","0.5500171","0.54979044","0.54795945","0.54688686","0.5467951","0.5466867","0.5458666","0.54546154","0.5454049","0.54499763","0.5441335","0.5437811","0.5437491","0.5434407","0.54279983","0.53908265","0.53825057","0.5376314","0.53753334","0.5372291","0.5364766","0.5351786","0.53362215","0.53331584","0.53256255","0.53145134","0.5308774","0.5302543","0.5300385","0.5298667","0.52967113","0.52870405","0.527753","0.52772963","0.5269985","0.52658033","0.5262871","0.5256123","0.5251584","0.52461326"],"string":"[\n \"0.6926132\",\n \"0.67918247\",\n \"0.66280645\",\n \"0.6622853\",\n \"0.6570255\",\n \"0.6499382\",\n \"0.64442146\",\n \"0.6332076\",\n \"0.62797856\",\n \"0.62646264\",\n \"0.6246257\",\n \"0.6151091\",\n \"0.6120761\",\n \"0.6096576\",\n \"0.60693115\",\n \"0.59628874\",\n \"0.5912617\",\n \"0.58920056\",\n \"0.58715844\",\n \"0.585937\",\n \"0.58575803\",\n \"0.58491397\",\n \"0.5846112\",\n \"0.5843997\",\n \"0.58173543\",\n \"0.5813309\",\n \"0.57830566\",\n \"0.57630634\",\n \"0.5756629\",\n \"0.57460064\",\n \"0.5741681\",\n \"0.57187223\",\n \"0.57041\",\n \"0.5703605\",\n \"0.56917787\",\n \"0.56906664\",\n \"0.5686903\",\n \"0.567886\",\n \"0.5677912\",\n \"0.5674802\",\n \"0.5674802\",\n \"0.5671491\",\n \"0.56708795\",\n \"0.56696886\",\n \"0.56674445\",\n \"0.56576335\",\n \"0.5630148\",\n \"0.562735\",\n \"0.5625279\",\n \"0.5614196\",\n \"0.56068265\",\n \"0.55967784\",\n \"0.55874074\",\n \"0.55793387\",\n \"0.55628\",\n \"0.55516875\",\n \"0.5541118\",\n \"0.55336416\",\n \"0.5523495\",\n \"0.55062515\",\n \"0.5500171\",\n \"0.54979044\",\n \"0.54795945\",\n \"0.54688686\",\n \"0.5467951\",\n \"0.5466867\",\n \"0.5458666\",\n \"0.54546154\",\n \"0.5454049\",\n \"0.54499763\",\n \"0.5441335\",\n \"0.5437811\",\n \"0.5437491\",\n \"0.5434407\",\n \"0.54279983\",\n \"0.53908265\",\n \"0.53825057\",\n \"0.5376314\",\n \"0.53753334\",\n \"0.5372291\",\n \"0.5364766\",\n \"0.5351786\",\n \"0.53362215\",\n \"0.53331584\",\n \"0.53256255\",\n \"0.53145134\",\n \"0.5308774\",\n \"0.5302543\",\n \"0.5300385\",\n \"0.5298667\",\n \"0.52967113\",\n \"0.52870405\",\n \"0.527753\",\n \"0.52772963\",\n \"0.5269985\",\n \"0.52658033\",\n \"0.5262871\",\n \"0.5256123\",\n \"0.5251584\",\n \"0.52461326\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.683124"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":94976,"cells":{"query":{"kind":"string","value":"Returns a hit, or None if the ray is parallel to the plane"},"document":{"kind":"string","value":"def intersect(self, ray):\n\n t = None\n hit = None\n angle = ray.dir.dot(self.norm)\n if angle != 0:\n t = (self.point - ray.start).dot(self.norm) / angle\n if angle < 0:\n hit = Hit(self, ray, t, float('inf'), self.norm, self.mat)\n else:\n hit = Hit(self, ray, float('-inf'), t, self.norm, self.mat)\n else:\n vector = unit(ray.start - self.point)\n if vector.dot(self.norm) < 0:\n hit = Hit(self, ray, float('-inf'), float('inf'), self.norm, self.mat)\n else:\n return None\n if (self.mat.texture is not None and not isninf(hit.entry)) > 0:\n hit.texCords = self.texCords(ray.pos(t))\n return hit"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def rayIntersection(self, ray):\n #t = \"what we are trying to find\"\n l = -ray.mDirection\n l0 = ray.mOrigin\n n = self.mNormal\n p0 = self.mDistance * n\n #p = l0 + l * t\n\n if l.dot(n) > 0:\n v = p0 - l0\n t = -(v.dot(n) / l.dot(n))\n return t\n\n else:\n return None","def intersect(self, ray):\n # TODO A5 (Step1) implement this function\n # Copy your implementation from A4\n # Then calculate uv coordinates, to be passed into the Hit initializer\n vs = self.vs\n\n a = vs[0][0] - vs[1][0]\n b = vs[0][1] - vs[1][1]\n c = vs[0][2] - vs[1][2]\n d = vs[0][0] - vs[2][0]\n e = vs[0][1] - vs[2][1]\n f = vs[0][2] - vs[2][2]\n\n ray_dir = ray.direction\n ray_orig = ray.origin\n\n g = ray_dir[0]\n h = ray_dir[1]\n i = ray_dir[2]\n j = vs[0][0] - ray_orig[0]\n k = vs[0][1] - ray_orig[1]\n l = vs[0][2] - ray_orig[2]\n\n M = a * (e * i - h * f) + b * (g * f - d * i) + c * (d * h - e * g)\n\n t = -(f * (a * k - j * b) + e * (j * c - a * l) + d *\n (b * l - k * c)) / M\n\n if (t < ray.start or t > ray.end):\n return no_hit\n\n gamma = (i * (a * k - j * b) + h * (j * c - a * l) + g *\n (b * l - k * c)) / M\n\n if (gamma < 0 or gamma > 1):\n return no_hit\n\n beta = (j * (e * i - h * f) + k * (g * f - d * i) +\n l * (d * h - e * g)) / M\n\n if (beta < 0 or beta > 1 - gamma):\n return no_hit\n\n P = ray_orig + t * ray_dir\n\n unit_normal = normalize(np.cross(vs[0] - vs[2], vs[1] - vs[2]))\n\n A = np.linalg.norm(np.cross(vs[1] - vs[0], vs[2] - vs[0])) / 2\n areaA = np.linalg.norm(np.cross(vs[1] - P, vs[2] - P)) / 2\n areaB = np.linalg.norm(np.cross(vs[0] - P, vs[2] - P)) / 2\n areaC = np.linalg.norm(np.cross(vs[0] - P, vs[1] - P)) / 2\n u = areaB / A\n v = areaC / A\n return Hit(t, P, unit_normal, vec([u, v]), self.material)","def next_hit(self, ray):\n hit_candidates = [(i.time_to_bound(ray), i) for i in self._bounds]\n try:\n # WARNING - A hard cut on 'times' smaller than 10^-9 is made to exclude\n # a beam reinteracting with the same barrier. This cuts out any legitimate\n # interactions closer than 1nm of the beam position.\n return (sorted([(time, surface) for time, surface in hit_candidates\n if time is not None and time > 1e-9 and all(\n [b.contains(ray.propagate(time).position) for b in self._bounds\n if b is not surface])])[0])\n except IndexError:\n return None","def intersect(self, ray):\n # TODO A5 (Step1) implement this function\n # Copy your implementation from A4\n # Then calculate uv coordinates, to be passed into the Hit initializer\n D = ray.direction\n E = ray.origin\n C = self.center\n R = self.radius\n B = 2*np.dot(D, E-C)\n A = np.dot(D, D)\n min_t = ray.start\n max_t = ray.end\n\n discriminant = B ** 2 - 4 * A * (np.dot(E-C, E-C)-R**2)\n\n if discriminant < 0:\n return no_hit\n\n t0 = (-1*B - np.sqrt(discriminant)) / (2*A)\n t1 = (-1*B + np.sqrt(discriminant)) / (2*A)\n\n if (t0 >= min_t and t0 <= max_t and t0 <= t1):\n t = t0\n elif (t1 >= min_t and t1 <= max_t):\n t = t1\n else:\n return no_hit\n\n P = E + t * D\n unit_normal = (P - C) / R\n d_hat = normalize(P - C)\n u = 0.5 + (np.arctan2(d_hat[0], d_hat[2])) / (2 * np.pi)\n v = 0.5 + (np.arcsin(d_hat[1])) / np.pi\n\n return Hit(t, P, unit_normal, vec([u, v]), self.material)","def intersectRay(self, ray):\n # Ray Tracing from the Ground Up, pg. 367\n a, b, c, d = self.a[0] - self.b[0], self.a[0] - self.c[0], ray.d[0], self.a[0] - ray.o[0]\n e, f, g, h = self.a[1] - self.b[1], self.a[1] - self.c[1], ray.d[1], self.a[1] - ray.o[1]\n i, j, k, L = self.a[2] - self.b[2], self.a[2] - self.c[2], ray.d[2], self.a[2] - ray.o[2]\n\n m, n, p = f * k - g * j, h * k - g * L, f * L - h * j\n q, s = g * i - e * k, e * j - f * i\n\n denom = a * m + b * q + c * s\n if denom < self.kEpsilon:\n return None\n\n inv_denom = 1.0 / denom\n\n e1 = d * m - b * n - c * p\n beta = e1 * inv_denom\n\n if 1.0 < beta or beta < 0.0:\n return None\n\n r = e * L - h * i\n e2 = a * n + d * q + c * r\n gamma = e2 * inv_denom\n\n if 1.0 < gamma or gamma < 0.0:\n return None\n\n e3 = a * p - b * r + d * s\n t = e3 * inv_denom\n\n if t < self.kEpsilon:\n return None\n\n return t","def intersects(self, ray):\n theta = 45\n H = 512\n W = 512\n A = self.origin\n B = Point(W, A.y, A.z)\n C = Point(B.x, (int)(H * math.sin(theta * math.pi / 180)), (int)(H * math.cos(math.pi * theta / 180)))\n D = Point(A.x, (int)(H * math.sin(theta * math.pi / 180)), (int)(H * math.cos(math.pi * theta / 180)))\n vec3 = ray.direction * self.normal\n if vec3 != 0:\n vec1 = self.origin - ray.origin\n vec2 = vec1 * self.normal\n dist = vec2 / vec3\n if dist > 0:\n point_on_plane = ray.origin + dist * ray.direction\n if A.x <= point_on_plane.x <= B.x and A.y <= point_on_plane.y <= D.y and B.z <= point_on_plane.z <= C.z:\n #print A, B, C, D, point_on_plane\n return dist","def intersectsAB(self, ray):\n v1 = ray.origin - self.pointA\n v2 = self.pointB - self.pointA\n v3 = Point(-ray.direction.y, ray.direction.x)\n dot = v2.dot(v3)\n if (abs(dot) < 0.000001):\n return None\n t1 = v2.cross(v1) / dot\n t2 = v1.dot(v3) / dot\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\n return t1\n return None","def raySegmentIntersectAB(self, ray):\n v1 = ray.origin - self.pointA\n v2 = self.pointB - self.pointA\n v3 = Point(-ray.direction.y, ray.direction.x)\n dot = v2.dot(v3)\n if (abs(dot) < 0.000001):\n return None\n t1 = v2.cross(v1) / dot\n t2 = v1.dot(v3) / dot\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\n return t1\n return None","def intersect(self, ray):\n # TODO A5 (Step3 and Step4) implement this function\n # For step 4, check if uvs and normals are not None (respectively)\n # If so, then interpolate them\n\n # batch_intersect returns t, beta, gamma, i\n posns = self.posns\n uvs = self.uvs\n inds = self.inds\n normals = self.normals\n t, beta, gamma, i = batch_intersect(posns[inds[:, :]], ray)\n if (t == np.inf):\n return no_hit\n vs = posns[inds[i, :]]\n P = ray.origin + t * ray.direction\n\n if (t == np.inf):\n return no_hit\n else:\n\n alpha = 1 - beta - gamma\n\n if uvs is not None:\n\n uv0 = uvs[inds[i][0]]\n uv1 = uvs[inds[i][1]]\n uv2 = uvs[inds[i][2]]\n\n uv = alpha * uv0 + beta * uv1 + gamma * uv2\n\n else:\n\n A = np.linalg.norm(np.cross(vs[1] - vs[0], vs[2] - vs[0])) / 2\n areaA = np.linalg.norm(np.cross(vs[1] - P, vs[2] - P)) / 2\n areaB = np.linalg.norm(np.cross(vs[0] - P, vs[2] - P)) / 2\n areaC = np.linalg.norm(np.cross(vs[0] - P, vs[1] - P)) / 2\n u = areaB / A\n v = areaC / A\n uv = vec([u, v])\n\n if normals is not None:\n\n n0 = normals[inds[i][0]]\n n1 = normals[inds[i][1]]\n n2 = normals[inds[i][2]]\n\n unit_normal = normalize(alpha * n0 + beta * n1 + gamma * n2)\n\n else:\n unit_normal = normalize(np.cross(vs[0] - vs[2], vs[1] - vs[2]))\n\n return Hit(t, P, unit_normal, uv, self.material)","def intersection(self, ray):\n d_proj = self._normal.dot(ray.d)\n if abs(d_proj) < bounds.too_small:\n return -1.0\n s_proj = (self._origin - ray.o).dot(self._normal)\n if d_proj * s_proj < 0.0:\n # ray going away from plane\n return -1.0\n else:\n return s_proj / d_proj","def rayIntersection(self, ray):\n\n rotVect = ray.mDirection #math3d.VectorN(math.cos(num), - math.sin(num), 0)\n\n # this give all the lines (red green and blue at the moment)\n tankPos = math3d.VectorN(ray.mOrigin[0], ray.mOrigin[1], 0)\n linkPos = math3d.VectorN(200,200,0)\n v = linkPos - tankPos\n added = (tankPos + getPara(v, rotVect) + getPerp(v, rotVect))\n added2 = tankPos + getPara(v, rotVect) #If the magnitude of this is minus the sphere origin is less than the radius you're in the sphere\n added3 = tankPos + getPerp(v, rotVect)\n added4 = tankPos + rotVect.normalized() * 200 #this is get point only change 200 to dist\n\n\n test = added2 - self.mCenter #checks if in center\n\n\n if test.magnitude() <= self.mRadius:\n green = added2 - ray.mOrigin #this is Qpara\n thing = (self.mSRadius - test.magnitude()**2) ** 0.5\n t = (green.magnitude() - thing)\n print(green.magnitude() - thing)\n return t\n else:\n return None\n\n #print(test.magnitude(), self.mRadius)\n #print(green.magnitude(), \"green\")","def _get_intersection(self, ray):\n\n intersection = None\n for obj in self.objects:\n dist = obj.intersects(ray)\n if dist is not None and \\\n (intersection is None or dist < intersection[1]):\n intersection = obj, dist\n\n return intersection","def time_to_bound(self, ray):\n incidence_cosine = dot(self._normal, ray.direction)\n aplanarity = (self._position - ray.position).dot(self._normal)\n if incidence_cosine == 0:\n # Ray parallel to plane. If aplanarity also 0, ray is in the plane.\n return None\n time = aplanarity / incidence_cosine\n return time if time > 0 else None","def getIntersection(self, ray):\n pass","def intersect(self, plane, epsilon=0.00001):\r\n den = np.dot(self.direction, plane.normal)\r\n if math.fabs(den) < epsilon:\r\n return None\r\n\r\n result = (-plane.distance - np.dot(plane.normal, self.origin)) / den\r\n\r\n if result < 0.0:\r\n if result < -epsilon:\r\n return None\r\n result = 0.0\r\n return result","def intersect(self, ray):\n # TODO A5 copy your implementation from A4\n surfaces = self.surfs\n\n min_t = np.inf\n i = no_hit\n\n for s in surfaces:\n intersect = s.intersect(ray)\n if (intersect.t < min_t):\n min_t = intersect.t\n i = intersect\n return i","def intersects(self, ray):\n sphere_to_ray = ray.origin - self.center\n a = 1\n b = 2 * ray.direction.dot_product(sphere_to_ray)\n c = sphere_to_ray.dot_product(sphere_to_ray) - self.radius * self.radius\n discriminant = b * b - 4 * a * c\n\n if discriminant >= 0:\n dist = (-b - sqrt(discriminant)) / 2\n if dist > 0:\n return dist\n\n return None","def HitTest(self, point, flags=0):\r\n \r\n w, h = self.GetSize()\r\n flags = 0\r\n \r\n if point.x < 0:\r\n flags |= TREE_HITTEST_TOLEFT\r\n if point.x > w:\r\n flags |= TREE_HITTEST_TORIGHT\r\n if point.y < 0:\r\n flags |= TREE_HITTEST_ABOVE\r\n if point.y > h:\r\n flags |= TREE_HITTEST_BELOW\r\n\r\n if flags:\r\n return None, flags\r\n \r\n if self._anchor == None:\r\n flags = TREE_HITTEST_NOWHERE\r\n return None, flags\r\n \r\n hit, flags = self._anchor.HitTest(self.CalcUnscrolledPosition(point), self, flags, 0)\r\n\r\n if hit == None: \r\n flags = TREE_HITTEST_NOWHERE\r\n return None, flags\r\n\r\n if not self.IsItemEnabled(hit):\r\n return None, flags\r\n\r\n return hit, flags","def is_intersecting(self, ray):\n\n intersecting_point = self._sympy_plane.intersection(ray.sympy_line)[0]\n\n if 'x' in self._name:\n\n if self._within_y_bounds(intersecting_point.y) and self._within_z_bounds(intersecting_point.z):\n return True, np.array(map(float, [intersecting_point.x, intersecting_point.y, intersecting_point.z]))\n\n\n\n elif 'y' in self._name:\n\n if self._within_x_bounds(intersecting_point.x) and self._within_z_bounds(intersecting_point.z):\n return True, np.array(map(float, [intersecting_point.x, intersecting_point.y, intersecting_point.z]))\n\n\n\n elif 'z' in self._name:\n\n if self._within_y_bounds(intersecting_point.y) and self._within_x_bounds(intersecting_point.x):\n return True, np.array(map(float, [intersecting_point.x, intersecting_point.y, intersecting_point.z]))\n\n return False, None","def shoot_ray(self, row, col):\n # Uses validate method to check if row,col are legal for ray entrance location\n if not self.valid_ray(row, col):\n return False\n # creates ray object from row, col integers\n ray = Ray(row, col)\n # checks if atom is in front of entrance position\n if not ray.can_continue(self.get_a_locations()):\n self.mark_portal(ray.get_start())\n if self.get_score() <= 0:\n self.change_state(\"LOST\")\n return None\n # while there is no atom in front of ray and ray will not exit board --\n while ray.can_continue(self.get_a_locations()):\n ray.check_diags(self.get_a_locations())\n # moves ray forward one space\n ray.advance()\n # if ray will exit board by advancing --\n if not ray.on_board():\n # adjusts score if entrance/exit do not match prior entrances/exits\n self.mark_portal(ray.get_start(), ray.get_pos())\n # changes state to lose if score is now <= 0\n if self.get_score() <= 0:\n self.change_state(\"LOST\")\n # returns tuple of exit location\n return tuple(ray.get_pos())\n # if ray is blocked by atom --\n if not ray.no_atom(self.get_a_locations()):\n # changes state to lost if score is now <= 0\n self.mark_portal(ray.get_start())\n if self.get_score() <= 0:\n self.change_state(\"LOST\")\n return None","def ray_segment_intersect(p_ray, d_ray, seg):\n d_seg = seg[1] - seg[0]\n\n t_max = np.linalg.norm(d_seg)\n\n d_seg = d_seg / t_max\n d_ray = d_ray / np.linalg.norm(d_ray)\n\n D = np.stack([d_ray, -d_seg], axis=1)\n b = seg[0] - p_ray\n\n try:\n T = np.linalg.solve(D, b)\n except np.linalg.LinAlgError as e:\n # D is a singular matrix, lines are parallel\n return None\n\n # 0 <= T[1] < t_max because if the ray intersects perfectly with vertices then they will\n # T[0] > 0 ray shoots only in one direction\n # be included twice because they are the end and the beginning of a two segments\n if 0 <= T[1] < t_max and T[0] > 0 and np.allclose(np.dot(D, T), b):\n return seg[0] + d_seg * T[1]\n else:\n return None","def intersection(self, line: AbstractLine) -> Optional[AbstractPoint]:\n plane = Plane(self.__point_a,\n self.__point_b - self.__point_a,\n self.__point_c - self.__point_a)\n\n point = plane.intersection(line)\n if point is not None:\n if self.has_point(point):\n return point\n return None","def intersects(self, ray):\n def raySegmentIntersectAB(self, ray):\n \"\"\"\n recibes a ray. checks if it intersects the segment\n dot: denominator. if dot = 0 they're paralel\n t1: distance from origin to intersection\n t2: intersection IN the segment\n \"\"\"\n v1 = ray.origin - self.pointA\n v2 = self.pointB - self.pointA\n v3 = Point(-ray.direction.y, ray.direction.x)\n dot = v2.dot(v3)\n if (abs(dot) < 0.000001):\n return None\n t1 = v2.cross(v1) / dot\n t2 = v1.dot(v3) / dot\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\n return t1\n return None\n \n def raySegmentIntersectCD(self, ray):\n v1 = ray.origin - self.pointC\n v2 = self.pointD - self.pointC\n v3 = Point(-ray.direction.y, ray.direction.x)\n dot = v2.dot(v3)\n if (abs(dot) < 0.000001):\n return None\n t1 = v2.cross(v1) / dot\n t2 = v1.dot(v3) / dot\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\n return t1\n return None\n \n def raySegmentIntersectAC(self, ray):\n v1 = ray.origin - self.pointA\n v2 = self.pointC - self.pointA\n v3 = Point(-ray.direction.y, ray.direction.x)\n dot = v2.dot(v3)\n if (abs(dot) < 0.000001):\n return None\n t1 = v2.cross(v1) / dot\n t2 = v1.dot(v3) / dot\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\n return t1\n return None\n\n def raySegmentIntersectBD(self, ray):\n v1 = ray.origin - self.pointB\n v2 = self.pointD - self.pointB\n v3 = Point(-ray.direction.y, ray.direction.x)\n dot = v2.dot(v3)\n if (abs(dot) < 0.000001):\n return None\n t1 = v2.cross(v1) / dot\n t2 = v1.dot(v3) / dot\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\n return t1\n return None\n \n \n minD = 9999\n distance_AB = raySegmentIntersectAB(self, ray)\n distance_CD = raySegmentIntersectCD(self, ray)\n distance_AC = raySegmentIntersectAC(self, ray)\n distance_BD = raySegmentIntersectBD(self, ray)\n \n if distance_AB is not None:\n minD = distance_AB\n \n if distance_CD is not None:\n if distance_CD < minD:\n minD = distance_CD\n \n if distance_AC is not None:\n if distance_AC < minD:\n minD = distance_AC\n \n if distance_BD is not None:\n if distance_BD < minD:\n minD = distance_BD\n\n if minD is not None:\n if minD != 9999:\n return minD\n return None\n \"\"\"\n minD = raySegmentIntersectBD(self, ray)\n #print (minD)\n return minD\n \"\"\"","def getRay(self, points, normed=False): # pragma: no cover\n # to be overloaded by the child class.\n return None","def intersection(self, segment):\n intersection = self.hyperplane.intersection(segment)\n if intersection is not None and np.linalg.norm(intersection - self.closest_point_to(intersection)) < epsilon:\n return intersection\n\n return None","def hit(self):\n return self._hit","def intersection(self, ray):\n \n points = []\n intersection_objects = []\n for obj in self.objects:\n intersection = obj.shape.intersection(ray)\n if intersection != None:\n for pt in intersection:\n points.append(pt)\n intersection_objects.append(obj)\n \n if len(points) == 0:\n return None, None\n return points, intersection_objects","def hit(bx, by, r, px, py,h):\n if bx >= px:\n distance = bx - px\n else:\n distance = px - bx\n if py<=by and by<=py+h and distance <= r:\n return True\n else:\n return False","def intersect(self,ray:Ray):\n o = ray.o #ray origin\n d = ray.d #ray destination\n oc = o - self.center #vector from ray origin to center\n b = 2*(oc*d)\n c = oc*oc - self.r**2\n disc = b**2-4*c\n if disc<0:\n return False,-1\n else:\n disc **=0.5\n t0 = -b-disc\n t1 = -b+disc\n return True,max(t0,t1)","def intersect(l: Line, p: Plane) -> Point:\n if math.isclose((l.d * p.normal()), 0):\n # If the line direction is perpendicular to the plane normal,\n # the line and plane must be parallel.\n return None\n else:\n # There exists a parameter t, which makes\n # p.isInPlane(l.point(t)) == 0\n # Let's find it.\n # Initial guess\n t1 = 1\n p1 = l.point(t1)\n d1 = distancePointPlane(p1, p)\n t2 = 2\n p2 = l.point(t2)\n d2 = distancePointPlane(p2, p)\n\n # Calculate line through the two points (t,d)\n a = (d2 - d1) / (t2 - t1)\n b = d1 - a * t1\n\n # Find the t-value where d is zero\n # 0 = at+b <=> t = -b/a\n t = -b / a\n print(\"parameter: {}\".format(t))\n return l.point(t)","def intersection_plane_plane_plane(plane1, plane2, plane3, epsilon=1e-6):\n line = intersection_plane_plane(plane1, plane2, epsilon)\n if not line:\n return None\n pt = intersection_line_plane(line, plane3, epsilon)\n if pt:\n return pt\n return None","def intersects(self, ray):\n\n sphere_to_ray = ray.origin - self.origin\n b = 2 * ray.direction * sphere_to_ray\n c = sphere_to_ray ** 2 - self.radius ** 2\n discriminant = b ** 2 - 4 * c\n\n if discriminant >= 0:\n dist = (-b - math.sqrt(discriminant)) / 2\n if dist > 0:\n return dist","def intersectsRay(self, ray):\n pass","def hit(self, ray_, t_min, t_max):\n raise NotImplemented(\"Override in subclass\")","def get_closest_node(self, point, plane=None):\n node = -1\n best_dist = 1.e100\n\n if len(point) == 3:\n # Seaching in 3d mesh\n meshz = self.get_data_value('ELEVATION Z', 0)\n for i in range(self.npoin3):\n dist = (self.meshx[i]- point[0])**2 + \\\n (self.meshy[i]- point[1])**2 + \\\n (meshz[i]- point[2])**2\n\n if dist < best_dist:\n best_dist = dist\n node = i\n\n elif len(point) == 2:\n if plane is None:\n # Searching in a 2d mesh\n for i in range(self.npoin2):\n dist = (self.meshx[i]- point[0])**2 + \\\n (self.meshy[i]- point[1])**2\n\n if dist < best_dist:\n best_dist = dist\n node = i\n else:\n # Searching in a given plane for the closest node\n for i in range(plane*self.npoin2, (plane+1)*self.npoin2):\n dist = (self.meshx[i]- point[0])**2 + \\\n (self.meshy[i]- point[1])**2\n\n if dist < best_dist:\n best_dist = dist\n node = i\n\n else:\n raise TelemacException(\\\n \"Point should be 2d or 3d: {}\".format(point))\n\n return node","def LinePlaneCollision(planeNormal, planePoint, rayDirection, rayPoint, epsilon=1e-12):\n\n ndotu = planeNormal.dot(rayDirection)\n if abs(ndotu) < epsilon:\n raise RuntimeError(\"no intersection or line is within plane\")\n\n w = rayPoint - planePoint\n si = -planeNormal.dot(w) / ndotu\n Psi = w + si * rayDirection + planePoint\n return Psi","def intersection_ray_ray_3d(ray1: Tuple[Vector, Vector],\n ray2: Tuple[Vector, Vector], abs_tol=1e-10) -> \\\nSequence[\n Vector]:\n # source: http://www.realtimerendering.com/intersections.html#I304\n o1, p1 = ray1\n d1 = (p1 - o1).normalize()\n o2, p2 = ray2\n d2 = (p2 - o2).normalize()\n d1xd2 = d1.cross(d2)\n denominator = d1xd2.magnitude_square\n if math.isclose(denominator, 0., abs_tol=abs_tol):\n # ray1 is parallel to ray2\n return tuple()\n else:\n o2_o1 = o2 - o1\n det1 = _determinant(o2_o1, d2, d1xd2)\n det2 = _determinant(o2_o1, d1, d1xd2)\n p1 = o1 + d1 * (det1 / denominator)\n p2 = o2 + d2 * (det2 / denominator)\n if p1.isclose(p2, abs_tol=abs_tol):\n # ray1 and ray2 have an intersection point\n return p1,\n else:\n # ray1 and ray2 do not have an intersection point,\n # p1 and p2 are the points of closest approach on each ray\n return p1, p2","def current_navmesh(self):\n source = self.transform.world_position.copy()\n source.z += 1\n\n target = source.copy()\n target.z -= 2\n\n result = self.physics.ray_test(target=target, source=source, mask=CollisionGroups.navmesh)\n\n if result is None:\n return None\n\n return result.entity","def ray_cast(self, max_distance):\n\t\tray_angle = radians(self.rotation)\n\n\t\t# Sense objects\n\t\tx, y = self.position\n\t\tclosest = None\n\t\tclosest_distance = float('inf')\n\t\tfor obj in self.get_scene_objects():\n\t\t\tif not hasattr(obj, 'position') or obj is self:\n\t\t\t\tcontinue\n\t\t\tobj_x, obj_y = obj.position\n\n\t\t\t# Figure out what the angle of this object is\n\t\t\t# relative to self\n\t\t\tdelta_x = obj_x - x\n\t\t\tdelta_y = y - obj_y\n\t\t\tangle = atan2(delta_y, delta_x) - pi/2\n\n\t\t\t# If the angle is acceptably in front of self\n\t\t\tif abs(angle - ray_angle) >= RAY_ANGLE_THRESHOLD:\n\t\t\t\tcontinue\n\n\t\t\tdist = self.distance_to(obj)\n\t\t\tif dist < closest_distance:\n\t\t\t\tclosest = obj\n\t\t\t\tclosest_distance = dist\n\n\t\tif closest is not None:\n\t\t\tif closest_distance <= max_distance:\n\t\t\t\treturn closest\n\t\t\t# Object is there, but not close enough\n\t\t\treturn None\n\n\t\t# Sense boundary\n\n\t\t# Divide the max_distance into components\n\t\t# based on the ray angle\n\t\tmax_x = max_distance * sin(ray_angle)\n\t\tmax_y = max_distance * cos(ray_angle)\n\n\t\t# Add the max_x and max_y to the current position\n\t\tmax_x = x - max_x\n\t\tmax_y = y - max_y\n\n\t\t# Check if either component is out of a boundary\n\t\tif max_x < 0:\n\t\t\treturn LEFT_BOUNDARY\n\t\telif max_x > self.get_screen_width():\n\t\t\treturn RIGHT_BOUNDARY\n\t\telif max_y < 0:\n\t\t\treturn TOP_BOUNDARY\n\t\telif max_y > self.get_screen_height():\n\t\t\treturn BOTTOM_BOUNDARY\n\n\t\t# Nothing found\n\t\treturn None","def hitTest( a, b ):\n r = a.radius + b.radius\n x = abs( a.x - b.x )\n y = abs( a.y - b.y )\n if x <= r and y <= r and x*x + y*y <= r*r:\n return 1\n return 0","def pick(self, start, direction, mat):\n new_mat = np.dot(\n np.dot(mat, self.translation_matrix),\n np.linalg.inv(self.scaling_matrix)\n )\n\n results = self.aabb.ray_hit(start, direction, mat)\n return results","def ray_status(ray, points, nodes):\n container = find_container(ray, nodes)\n \n # Handle special case of last step where ray is hitting the world node\n root = nodes[0].root\n if container == root and len(nodes) == 1:\n status = root, None, root\n return status\n\n if nodes[0] == container:\n surface_node = nodes[0]\n to_node = nodes[1]\n else:\n surface_node = nodes[0]\n to_node = nodes[0]\n status = container, to_node, surface_node\n return status","def HitTest(self, point, flags=0):\r\n\r\n w, h = self.GetSize()\r\n column = -1\r\n\r\n if not isinstance(point, wx.Point):\r\n point = wx.Point(*point)\r\n\r\n if point.x < 0:\r\n flags |= wx.TREE_HITTEST_TOLEFT\r\n if point.x > w:\r\n flags |= wx.TREE_HITTEST_TORIGHT\r\n if point.y < 0:\r\n flags |= wx.TREE_HITTEST_ABOVE\r\n if point.y > h:\r\n flags |= wx.TREE_HITTEST_BELOW\r\n if flags:\r\n return None, flags, column\r\n\r\n if not self._anchor:\r\n flags = wx.TREE_HITTEST_NOWHERE\r\n column = -1\r\n return None, flags, column\r\n \r\n hit, flags, column = self._anchor.HitTest(self.CalcUnscrolledPosition(point), self, flags, column, 0)\r\n if not hit:\r\n flags = wx.TREE_HITTEST_NOWHERE\r\n column = -1\r\n return None, flags, column\r\n \r\n return hit, flags, column","def trace(self, ray): # type: (Ray) -> Vector\n hit_object = None\n t = numpy.inf\n\n for scene_object in self.scene.shapes:\n t0 = scene_object.intersect(ray)\n if t0 < t:\n t = t0\n hit_object = scene_object\n\n # if there were no intersections, then return the background colour\n if t == numpy.inf:\n return self.scene.camera.background\n\n hit_point = ray.origin + ray.direction * t\n normal = hit_object.normal(hit_point)\n luminance = 0.0\n\n # perform shading calculations\n for light in self.scene.lights:\n hit_point_to_light = (light.centre - hit_point).normal\n\n #check whether this light contributes to the shading\n in_shadow = False\n for shadower in self.scene.shapes:\n # we don't want to test against itself\n if shadower == hit_object:\n continue\n shadow_ray = Ray(hit_point + normal * 0.0001, hit_point_to_light)\n if shadower.intersect(shadow_ray) < numpy.inf:\n in_shadow = True\n break\n if in_shadow:\n continue\n\n # super simple lambertian lighting model\n luminance += hit_point_to_light.dot(normal) * light.power\n\n # calculate shaded colour - luminance may be over one if there are multiple light sources\n # normally this would be dealt with by HDR and tone mapping but is just clipped\n # in demo ray tracers\n object_colour = hit_object.material.colour * min(luminance, 1.0)\n\n # calculate reflection colour if material has reflectance\n if hit_object.material.reflectance != 0.0 and ray.depth != self.scene.camera.depth:\n reflected_direction = (ray.direction - normal * 2 * (ray.direction.dot(normal))).normal\n # we need to 'translate' the reflection vector away from the hitpoint otherwise\n # we risk intersecting the original hit point again which causes artifacts in the reflection\n reflected_ray = Ray(hit_point + reflected_direction * 0.0001, reflected_direction, ray.depth + 1)\n reflection_colour = self.trace(reflected_ray)\n\n # interpolate shaded colour and reflected colour based on reflectance\n return Vector(*[lerp(object_colour.data[i], reflection_colour.data[i], hit_object.material.reflectance) for i in range(3)])\n\n return object_colour","def ray(self):\n return self._ray","def LinePlaneIntersection(line, plane):\n plane = rhutil.coerceplane(plane, True)\n line_points = rhutil.coerce3dpointlist(line, True)\n line = Rhino.Geometry.Line(line_points[0], line_points[1])\n rc, t = Rhino.Geometry.Intersect.Intersection.LinePlane(line, plane) \n if not rc: return scriptcontext.errorhandler()\n return line.PointAt(t)","def time_to_bound(self, ray):\n qr_a = ray.direction.dot(ray.direction)\n qr_b = 2. * (ray.position - self._center).dot(ray.direction)\n qr_c = np.linalg.norm(ray.position - self._center)**2 - self._radius**2\n radical_arg = qr_b**2 - (4. * qr_a * qr_c)\n try:\n if qr_b < 0:\n quadratic = (-qr_b - sqrt(radical_arg)) / 2.\n else:\n quadratic = (-qr_b + sqrt(radical_arg)) / 2.\n if quadratic != 0.0:\n return min((i for i in (quadratic / qr_a, qr_c / quadratic) if i > 0))\n except ValueError:\n # Root is imaginary. Pass this to return None.\n pass\n return None","def get_atom_hit(self):\r\n return Marker((0, 128, 0), self._screen)","def intersect_plane(L, plane):\n \n # Line U, V\n # Plane N n\n # (VxN-nU:U.N)\n # Note that this is in homogeneous coordinates.\n # intersection of plane (n,p) with the line (v,p)\n # returns point and line parameter\n \n \n den = np.dot(L.w, plane.n)\n \n if abs(den) > (100*_eps):\n P = -(np.cross(L.v, plane.n) + plane.p * L.w) / den\n p = (np.cross(L.v, plane.n) - plane.p * L.w) / den\n \n P = L.pp\n t = np.dot( P-p, N)\n return namedtuple('intersect_plane', 'p t')(P, t)\n else:\n return None","def _next_hit(self, elements):\n hits = ((item, item.next_hit(self._ray)) for item in elements)\n try:\n return sorted(\n [(hit[0], hit[1], item) for item, hit in hits if hit is not None])[0]\n except IndexError:\n return None","def point_of_intersection(l, pz=distance):\r\n # Must fix the error here. Right now, any vector can have a point in the plane.\r\n # Must make it so that only vectors pointing in the planes direction has a point there\r\n # Can be done by checking whether d is positive or not.\r\n # This is to prevent vectors that point away from the detector to be counted\r\n # The definitions below assume that the detector is centred in the origin and its length is oriented along the z-axis.\r\n p0 = np.array([0,0,pz]) # Point on the plane\r\n l0 = np.array([0,0,0]) # Point on the line\r\n n = np.array([0,0,1]) # Normal vector of the plane\r\n d = np.dot(p0-l0, n)/np.dot(l, n)\r\n point = [i*d for i in l]\r\n return point","def shoot_ray(self, entry_x, entry_y):\r\n\r\n # check to make sure entry_x and entry_y are valid\r\n if (entry_x in [0, 9] or entry_y in [0, 9]) and \\\r\n self._board.get_board_item(entry_x, entry_y) != \"o\":\r\n\r\n exit_tup = self._board.find_exit(entry_x, entry_y)\r\n # returned 0 if hit\r\n if exit_tup == 0:\r\n # decrement entry only if not visited\r\n marker = self.get_hit_marker()\r\n circle_tuple = self.calculate_entry_exit(entry_y, entry_x)\r\n marker.update_center(circle_tuple)\r\n points = self._player.add_entry_exit((entry_x, entry_y), marker,\r\n (entry_x, entry_y))\r\n self._stats.dec_player_score(points)\r\n return \"Hit\"\r\n elif exit_tup == 1:\r\n # decrement entry only if not visited\r\n marker = self.get_reflect_marker()\r\n circle_tuple = self.calculate_entry_exit(entry_y, entry_x)\r\n marker.update_center(circle_tuple)\r\n points = self._player.add_entry_exit((entry_x, entry_y), marker,\r\n (entry_x, entry_y))\r\n\r\n self._stats.dec_player_score(points)\r\n\r\n return \"reflect\"\r\n else:\r\n # decrement both entry and exit if not already visited\r\n marker = self.get_color_marker()\r\n exit_x, exit_y = exit_tup\r\n circle_entry = self.calculate_entry_exit(entry_y, entry_x)\r\n circle_exit = self.calculate_entry_exit(exit_y, exit_x)\r\n marker.update_center(circle_entry, circle_exit)\r\n points = self._player.add_entry_exit((entry_x, entry_y),\r\n marker, exit_tup)\r\n\r\n self._stats.dec_player_score(points)\r\n return exit_tup\r\n else:\r\n # returns false if the shoot_ray point is invalid\r\n return \"Bad shot\"","def getClosestPointFromLine(origin, ray, point):\n # calculate the difference vector\n delta = point-origin\n # norm the ray\n ray /= np.linalg.norm(ray, axis=-1)[..., None]\n # calculate the scale product\n factor = np.sum(ray*delta, axis=-1)\n try:\n return origin + factor[:, None] * ray\n except IndexError:\n return origin + factor * ray","def reflect(self, ray):\n normal = self.normal(ray.position)\n if normal.dot(ray.direction) > 0:\n normal = -normal\n return Ray(\n ray.direction - 2 * dot(ray.direction, normal) * normal, ray.position)","def ray(self, pixel):\n # Ensure pixel is in homogenous coordinates\n if len(pixel) == 2:\n pixel = np.vstack((pixel, [1]))\n\n ray = project(self._camera.P_pinv, pixel.astype(np.float32))\n assert ray.shape == (4, 1)\n\n return self._camera.center, ray","def intersection_line_plane(line, plane, epsilon=1e-6):\n pt1 = line[0]\n pt2 = line[1]\n p_cent = plane[0]\n p_norm = plane[1]\n\n v1 = subtract_vectors(pt2, pt1)\n dot = dot_vectors(p_norm, v1)\n\n if abs(dot) > epsilon:\n v2 = subtract_vectors(pt1, p_cent)\n fac = -dot_vectors(p_norm, v2) / dot\n vec = scale_vector(v1, fac)\n return add_vectors(pt1, vec)\n else:\n return None","def ray_at(self, O, t):\n point = self.float_mul(t).plus(O)\n return point","def _hit_span_get(self):\n try:\n return self.hit_end - self.hit_start\n except TypeError: # triggered if any of the coordinates are None\n return None","def ray_intersect_triangle(origin, direction, triangle, use_planes=False):\n origin = np.array(origin)\n direction = np.array(direction)\n if len(direction.shape) == 1:\n direction = direction.reshape(1, *direction.shape)\n return_single = True\n else:\n return_single = False\n triangle = np.array(triangle)\n if len(triangle.shape) == 2:\n triangle = triangle.reshape(1, *triangle.shape)\n\n v0 = triangle[..., 0, :]\n v1 = triangle[..., 1, :]\n v2 = triangle[..., 2, :]\n u = v1 - v0\n v = v2 - v0\n normal = np.cross(u, v)\n b = np.inner(normal, direction)\n a = my_inner(normal[..., None, :], v0[..., None, :] - origin[None, ..., :])\n\n rI = a / b\n # ray is parallel to the plane\n rI[(b == 0.0)*(a != 0.0)] = np.nan\n # ray is parallel and lies in the plane\n rI[(b == 0.0)*(a == 0.0)] = 0\n\n # check whether the intersection is behind the origin of the ray\n rI[rI < 0.0] = np.nan\n\n if not use_planes:\n w = origin + rI[..., None] * direction - v0[..., None, :]\n denom = my_inner(u, v) * my_inner(u, v) - my_inner(u, u) * my_inner(v, v)\n\n si = (my_inner(u, v)[..., None] * my_inner(w, v[..., None, :]) - my_inner(v, v)[..., None] * my_inner(w, u[..., None, :])) / denom[:, None]\n rI[((si < 0)+(si > 1.0)).astype(bool)] = np.nan\n\n ti = (my_inner(u, v)[..., None] * my_inner(w, u[..., None, :]) - my_inner(u, u)[..., None] * my_inner(w, v[..., None, :])) / denom[:, None]\n rI[((ti < 0.0) + (si + ti > 1.0)).astype(bool)] = np.nan\n\n def nanargmin(a, axis):\n from numpy.lib.nanfunctions import _replace_nan\n a, mask = _replace_nan(a, np.inf)\n res = np.argmin(a, axis=axis)\n return res\n\n index = nanargmin(rI, axis=0)\n rI = rI[index, np.arange(len(index))]\n point = origin + rI[..., None] * direction\n\n if return_single:\n return point[0]\n return point","def intersection(self, segment):\n p0, p1 = segment.p0, segment.p1\n\n # x = t*(p1 - p0) + p0\n # n'*(x - origin) = 0\n # combine to get\n # n'*(t*(p1-p0) + p0 - origin) = 0\n # solve for t\n\n v = p1 - p0\n w = p0 - self.origin\n t = -np.dot(self.normal, w)/np.dot(self.normal, v)\n\n if 0-epsilon <= t <= 1+epsilon:\n return t*(p1-p0) + p0\n else:\n return None","def simpleObjPickRoad(obj, roads):\n # in here the obj (either union or terrace) consists of one building\n fittestRid = -1\n accessPoint = Point(0, 0)\n\n findRoad = False\n\n for road in roads:\n reference = road.geom.project(obj.centroid)\n tempAccessPoint = road.geom.interpolate(reference)\n PointC = (obj.centroid.x, obj.centroid.y)\n PointD = (tempAccessPoint.x, tempAccessPoint.y)\n lineCD = LineString((PointC, PointD))\n\n if type(obj) == pg_read.Union:\n # now we are using a union\n uid = obj.id\n cur.execute(\"select * from unions \\\n where st_intersects(geom, st_geomfromtext('%s', 27700)) \\\n and uid != %d\" % (lineCD.wkt, uid)) # NOQA\n results = cur.fetchall()\n if not results:\n # which means no other unions intersects lineCD\n findRoad = True\n fittestRid = road.id\n accessPoint = tempAccessPoint\n break\n else:\n # which means we are using a terrace\n tid = obj.id\n cur.execute(\"select * from terraces \\\n where st_intersects(geom, st_geomfromtext('%s', 27700)) \\\n and tid != %d\" % (lineCD.wkt, tid)) # NOQA\n results = cur.fetchall()\n if not results:\n # which means no other terraces intersects lineCD\n findRoad = True\n fittestRid = road.id\n accessPoint = tempAccessPoint\n break\n\n if findRoad:\n # if findRoad == True:\n return fittestRid, accessPoint\n else:\n # which means findRoad == False\n # I know it's sad, but we need to have default option here\n # we use the roads[0] as accessRoad anyway\n road = roads[0]\n reference = road.geom.project(obj.centroid)\n fittestRid = road.id\n accessPoint = road.geom.interpolate(reference)\n return fittestRid, accessPoint","def trace(self):\n\n \n assert self.scene != None, \"The photon's scene variable is not set.\"\n \n intersection_points, intersection_objects = self.scene.intersection(self.ray)\n\n \"\"\"\n #DIAGNOSTICS\n print \"\\nnew\\n\"\n print self.position, self.direction, \"\\n\"\n print intersection_points, \"\\n\"\n for i in range(0, len(intersection_objects)):\n print \"Object: \", intersection_objects[i].name, \" - Intersection: \", intersection_points[i]\n \"\"\"\n \n assert intersection_points != None, \"The ray must intersect with something in the scene to be traced.\"\n \n if self.container is None:\n self.container = self.scene.container(self)\n assert self.container != None, \"Container of ray cannot be found.\"\n \n #import pdb; pdb.set_trace()\n #import pudb; pudb.set_trace()\n intersection_points, intersection_objects = Scene.sort(intersection_points, intersection_objects, self, container=self.container, show_log=self.show_log)\n \n # find current intersection point and object -- should be zero if the list is sorted!\n intersection = closest_point(self.position, intersection_points)\n for i in range(0,len(intersection_points)):\n if list(intersection_points[i]) == list(intersection):\n index = i\n break\n \n #import pdb; pdb.set_trace()\n intersection_object = intersection_objects[index]\n assert intersection_object != None, \"No intersection points can be found with the scene.\"\n \n \n \"\"\"\n #DIAGNOSTICS\n print \"\\n\", intersection, \"\\n\"\n print intersection_object.name \n \"\"\" \n \n \n # Reached scene boundaries?\n if intersection_object is self.scene.bounds:\n self.active = False\n self.previous_container = self.container\n self.container = self.scene.bounds\n return self\n\n\n # Reached a RayBin (kind of perfect absorber)?\n if isinstance(intersection_object, RayBin):\n self.active = False\n self.previous_container = self.container\n self.container = self.scene.bounds\n return self\n \n \n # Here we trace the ray through a Coating\n if isinstance(self.container, Coating):\n normal = intersection_object.shape.surface_normal(self.ray)\n self = self.container.material.trace(self, normal, separation(self.position, intersection))\n self.exit_device = self.container\n self.previous_container = self.container\n self.container = self.scene.container(self)\n return self\n \n \n # Here we determine if the Coating has been hit\n if isinstance(intersection_object, Coating) and intersection_object.shape.on_surface(self.position):\n self.previous_container = self.container\n self.container = intersection_object\n self.exit_device = intersection_object\n assert self.exit_device != self.scene.bounds, \"The object the ray hit before hitting the bounds is the bounds, this can't be right.\"\n return self\n \n \n # Here we trace the ray through a Material\n self = self.container.material.trace(self, separation(self.position, intersection))\n \n \n # Lost in material?\n # Photon has been re-absorbed but NOT re-emitted, i.e. is inactive\n if not self.active:\n #01/04/10: Unification --> Next two lines came from older Trace version\n self.exit_device = self.container\n self.exit_material = self.container.material\n return self \n \n # Reaches interface\n # Photon has been re-absorbed AND re-emitted, i.e. is still active\n ray_on_surface = intersection_object.shape.on_surface(self.position)\n if not ray_on_surface: \n self.exit_device = self.container\n return self\n \n # Ray has reached a surface of some description, increment the intersection counter\n self.intersection_counter += 1\n \n # If we reach an reflective material then we don't need to follow \n # this logic we can just return\n if ray_on_surface and isinstance(intersection_object, Coating):\n self.previous_container = self.container\n self.container = intersection_object\n self.exit_device = intersection_object\n return self\n \n # KARLG NEW CODE HERE\n #import pudb; pudb.set_trace()\n if isinstance(intersection_object, Face):\n self.exit_device = intersection_object\n \n # Now change the properties of the photon accoring to what your surface does\n random_number = np.random.random_sample()\n if random_number < intersection_object.reflectivity:\n # Reflected\n self.direction = reflect_vector(intersection_object.shape.surface_normal(self.ray), self.direction)\n elif random_number < intersection_object.reflectivity + intersection_object.transmittance:\n # Transmitted\n pass\n else:\n # Loss\n self.active = False\n return self\n \n # Fresnel details\n normal = intersection_object.shape.surface_normal(self.ray)\n rads = angle(normal, self.direction)\n \n # material-air or material-material interface\n # Are there duplicates intersection_points that are equal to the ray position?\n same_pt_indices = []\n for i in range(0,len(intersection_points)):\n if cmp_points(self.position, intersection_points[i]):\n same_pt_indices.append(i)\n assert len(same_pt_indices) < 3, \"An interface can only have 2 or 0 common intersection points.\"\n \n initialised_internally = None\n \n if len(same_pt_indices) == 2:\n intersection_object = self.container\n \n if self.container == intersection_object:\n \n # hitting internal interface -- for the case we are at an material-material interface (i.e. not travelling through air)\n initialised_internally = True\n \n if len(same_pt_indices) == 2:\n \n for obj in intersection_objects:\n if obj.shape.on_surface(intersection) and obj != self.container:\n #if obj != self.container:\n next_containing_object = obj\n \n \n else:\n # hitting internal interface -- for the case we are not at an interface\n next_containing_object = self.scene.container(self)\n \n assert self.container != next_containing_object, \"The current container cannot also be the next containing object after the ray is propagated.\"\n \n # Fresnel details\n normal = intersection_object.shape.surface_normal(self.ray)\n rads = angle(normal, self.direction)\n if self.polarisation == None:\n reflection = fresnel_reflection(rads, self.container.material.refractive_index, next_containing_object.material.refractive_index)\n else:\n reflection = fresnel_reflection_with_polarisation(normal, self.direction, self.polarisation, self.container.material.refractive_index, next_containing_object.material.refractive_index)\n \n else:\n # hitting external interface\n initialised_internally = False \n \n \n if len(same_pt_indices) == 2:\n for obj in intersection_objects:\n if obj != self.container:\n intersection_object = obj\n next_containing_object = obj\n else:\n next_containing_object = intersection_object\n \n #import pdb; pdb.set_trace()\n normal = intersection_object.shape.surface_normal(self.ray)\n rads = angle(normal, self.direction)\n if self.polarisation == None:\n reflection = fresnel_reflection(rads, self.container.material.refractive_index, next_containing_object.material.refractive_index)\n else:\n reflection = fresnel_reflection_with_polarisation(normal, self.direction, self.polarisation, self.container.material.refractive_index, next_containing_object.material.refractive_index)\n \n if isinstance(next_containing_object, Collector):\n # If the photon hits an interface with e.g. a cell index-matched to it, then no reflection is to occur at this interface.\n reflection = 0.\n \n if np.random.random_sample() < reflection:\n # photon is reflected\n before = copy(self.direction)\n self.direction = reflect_vector(normal, self.direction)\n ang = angle(before, self.direction)\n \n if self.polarisation != None:\n \n #import pdb; pdb.set_trace()\n if cmp_floats(ang, np.pi):\n # Anti-parallel\n self.polarisation = self.polarisation\n else:\n # apply the rotation transformation the photon polarisation which aligns the before and after directions\n R = rotation_matrix_from_vector_alignment(before, self.direction)\n self.polarisation = transform_direction(self.polarisation, R)\n \n assert cmp_floats(angle(self.direction, self.polarisation), np.pi/2), \"Exit Pt. #1: Angle between photon direction and polarisation must be 90 degrees: theta=%s\" % str(np.degrees(angle(self.direction, self.polarisation)))\n \n self.propagate = False\n self.exit_device = self.container\n \n # invert polaristaion if n1 < n2\n if self.container.material.refractive_index < next_containing_object.material.refractive_index:\n \n if self.polarisation != None:\n \n if cmp_floats(ang, np.pi):\n # Anti-parallel\n self.polarisation = self.polarisation * -1.\n else:\n # apply the rotation transformation the photon polarisation which aligns the before and after directions\n R = rotation_matrix_from_vector_alignment(before, self.direction)\n self.polarisation = transform_direction(self.polarisation, R)\n \n assert cmp_floats(angle(self.direction, self.polarisation), np.pi/2), \"Exit Pt. #2: Angle between photon direction and polarisation must be 90 degrees: theta=%s\" % str(angle(self.direction, self.polarisation))\n \n if self.exit_device == self.scene.bounds or self.exit_device == None:\n self.exit_device = intersection_object\n assert self.exit_device != self.scene.bounds, \"The object the ray hit before hitting the bounds is the bounds, this can't be right\"\n return self\n else:\n # photon is refracted through interface\n self.propagate = True\n before = copy(self.direction)\n ang = angle(before, self.direction)\n if initialised_internally:\n if not isinstance(next_containing_object, Collector):\n self.direction = fresnel_refraction(normal, self.direction, self.container.material.refractive_index, next_containing_object.material.refractive_index )\n \n if self.polarisation != None:\n if cmp_floats(ang, np.pi):\n # Anti-parallel\n self.polarisation = self.polarisation\n else:\n # apply the rotation transformation the photon polarisation which aligns the before and after directions\n R = rotation_matrix_from_vector_alignment(before, self.direction)\n self.polarisation = transform_direction(self.polarisation, R)\n assert cmp_floats(angle(self.direction, self.polarisation), np.pi/2), \"Exit Pt. #3: Angle between photon direction and polarisation must be 90 degrees: theta=%s\" % str(angle(self.direction, self.polarisation))\n \n self.exit_device = self.container #LSC is the exit_device\n self.previous_container = self.container\n self.container = next_containing_object #Bounds is the container\n return self\n else:\n if not isinstance(next_containing_object, Collector):\n self.direction = fresnel_refraction(normal, self.direction, self.container.material.refractive_index, intersection_object.material.refractive_index )\n \n if self.polarisation != None:\n \n if cmp_floats(ang, np.pi):\n # Anti-parallel\n self.polarisation = self.polarisation\n else:\n # apply the rotation transformation the photon polarisation which aligns the before and after directions\n R = rotation_matrix_from_vector_alignment(before, self.direction)\n self.polarisation = transform_direction(self.polarisation, R)\n # apply the rotation transformation the photon polarisation which aligns the before and after directions\n\n assert cmp_floats(angle(self.direction, self.polarisation), np.pi/2), \"Exit Pt. #4: Angle between photon direction and polarisation must be 90 degrees: theta=%s\" % str(angle(self.direction, self.polarisation))\n \n # DJF 13.5.2010: This was crashing the statisical collection because it meant that an incident ray, hitting and transmitted, then lost would have bounds as the exit_device.\n #self.exit_device = self.container\n self.exit_device = intersection_object\n self.previous_container = self.container\n self.container = intersection_object\n return self","def obj_ray_cast(obj, matrix):\r\n \r\n # get the ray relative to the object\r\n matrix_inv = matrix.inverted()\r\n ray_origin_obj = matrix_inv * ray_origin\r\n ray_target_obj = matrix_inv * ray_target\r\n ray_direction_obj = ray_target_obj - ray_origin_obj\r\n \r\n # cast the ray\r\n success, location, normal, face_index = obj.ray_cast(ray_origin_obj, ray_direction_obj)\r\n \r\n if success:\r\n return location, normal, face_index\r\n else:\r\n return None, None, None","def is_hit(ball, r_ball, v, target, r_target):\n v_norm = norm_2d(v)\n dr = (target[0] - ball[0], target[1] - ball[1])\n dr_norm = norm_2d(dr)\n\n p = project(dr, v)\n p_norm = norm_2d(p)\n\n if p_norm > v_norm:\n c = (v_norm ** 2 + dr_norm ** 2 - 2 * sc_mul(v, dr)) ** 0.5\n return c <= r_ball + r_target\n\n h = get_point_line_distance(target, ball, (-v[1], v[0]))\n return abs(h) <= r_ball + r_target","def obj_ray_cast(obj, matrix):\n\n # get the ray relative to the object\n matrix_inv = matrix.inverted()\n ray_origin_obj = matrix_inv * ray_origin\n ray_target_obj = matrix_inv * ray_target\n ray_direction_obj = ray_target_obj - ray_origin_obj\n \n # cast the ray\n success, location, normal, face_index = obj.ray_cast(ray_origin_obj, ray_direction_obj)\n\n if success:\n return location, normal, face_index, ray_target\n else:\n return None, None, None, ray_target","def obj_ray_cast(obj, matrix):\n\n # get the ray relative to the object\n matrix_inv = matrix.inverted()\n ray_origin_obj = matrix_inv * ray_origin\n ray_target_obj = matrix_inv * ray_target\n ray_direction_obj = ray_target_obj - ray_origin_obj\n\n # cast the ray\n success, location, normal, face_index = obj.ray_cast(ray_origin_obj, ray_direction_obj)\n\n if success:\n return location, normal, face_index\n else:\n return None, None, None","def closest_point_on_plane(point, plane):\n base, normal = plane\n x, y, z = base\n a, b, c = normalize_vector(normal)\n x1, y1, z1 = point\n d = a * x + b * y + c * z\n k = (a * x1 + b * y1 + c * z1 - d) / (a**2 + b**2 + c**2)\n return [x1 - k * a,\n y1 - k * b,\n z1 - k * c]","def on_road(self):\n for obj in self.model.grid[self.pos[0]][self.pos[1]]:\n if obj.agent_type == \"road\":\n return obj","def obj_ray_cast(obj, matrix):\n\n # get the ray relative to the object\n matrix_inv = matrix.inverted()\n ray_origin_obj = matrix_inv @ ray_origin\n ray_target_obj = matrix_inv @ ray_target\n ray_direction_obj = ray_target_obj - ray_origin_obj\n\n # cast the ray\n success, location, normal, face_index = obj.ray_cast(ray_origin_obj, ray_direction_obj)\n\n if success:\n return location, normal, face_index\n else:\n return None, None, None","def follow(ray: Ray, scene: Scene, max_iters=1000, renderer=None) -> [Tuple[Ray, Decision]]:\n path = [(ray, Decision.EMIT)]\n idx = 0\n last_ray = ray\n while ray.is_alive:\n intersections = scene.intersections(ray.position, ray.direction)\n points, nodes = zip(*[(x.point, x.hit) for x in intersections])\n for ray, decision in step(ray, points, nodes, renderer=renderer):\n path.append((ray, decision))\n if points_equal(ray.position, last_ray.position) and np.allclose(ray.direction, last_ray.direction):\n raise TraceError(\"Ray did not move.\")\n last_ray = ray\n if idx > max_iters:\n raise TraceError(\"Ray got stuck.\")\n return path","def HitTest(self, x, y):\r\n\r\n return 0","def get_point(k, refpt):\n i = 0\n while i < k:\n rho, theta = np.random.uniform(r, 2*r), np.random.uniform(0, 2*np.pi)\n pt = refpt[0] + rho*np.cos(theta), refpt[1] + rho*np.sin(theta), 0\n if not (0 <= pt[0] < width and 0 <= pt[1] < height):\n # This point falls outside the domain of the grid, so try again.\n i += 1\n continue\n if point_valid(pt) and is_on_face(pt, v1, v2, v3):\n return pt\n i += 1\n # We failed to find a suitable point in the vicinity of refpt.\n return False","def hit(self, origin, sightVector, hitError):\n distance = [0, 0, 0]\n for i in range(0, 3):\n distance[i] = self.translation[i] - origin[i]\n v1 = normalize(distance)\n v2 = normalize(sightVector)\n return abs(v1[0] - v2[0]) < hitError and \\\n abs(v1[1] - v2[1]) < hitError and abs(v1[2] - v2[2]) < hitError","def hit(self, otherball):\r\n dx = (self.unif[0] + self.vx) - (otherball.unif[0] + otherball.vx)\r\n dy = (self.unif[1] + self.vy) - (otherball.unif[1] + otherball.vy)\r\n rd = self.radius + otherball.radius\r\n return dot(dx, dy) < (rd * rd)","def step(ray, points, nodes, renderer=None):\n container, to_node, surface_node = ray_status(ray, points, nodes)\n min_point = ray.position\n max_point = points[0]\n \n dist = distance_between(min_point, max_point)\n _ray = ray\n for (ray, decision) in trace_path(ray, container, dist):\n if renderer:\n renderer.add_ray_path([_ray, ray])\n _ray = ray\n yield ray, decision\n\n if to_node is None and container.parent is None:\n # Case: Hit world node; kill ray here.\n ray = replace(ray, is_alive=False)\n yield ray, Decision.KILL\n elif points_equal(ray.position, max_point):\n # Case: Hit surface\n # NB The ray argument of `trace_surface` *must* be a ray on the surface of the \n # node and the returned ray must *not* be on the node!\n before_ray = ray\n _ray = ray\n for ray, decision in trace_surface(ray, container, to_node, surface_node):\n if renderer:\n renderer.add_ray_path([_ray, ray])\n _ray = ray\n yield ray, decision\n # Avoid error checks in production\n if __debug__:\n local_ray = ray.representation(surface_node.root, surface_node)\n if surface_node.geometry.is_on_surface(local_ray.position):\n logger.warning(\"(before) pos: {}\".format(before_ray.position))\n logger.warning(\"(after) pos: {}\".format(ray.position))\n raise TraceError(\"After tracing a surface the ray cannot still be on the surface.\")","def point_sur_segment(self, pt):\n dp = pt - self.c\n d = dp.length - self.r\n a = atan2(dp.y, dp.x)\n t = (a - self.a0) / self.da\n return t > 0 and t < 1, d, t","def sample(self, z_position):\n if self.direction[2] != 0:\n z_plane = PlaneSurface([0, 0, 1], [0, 0, z_position])\n if (z_plane.position() - self.position).dot(self.direction) > 0:\n ray = self\n else:\n ray = Ray(-self.direction, self.position)\n return ray.propagate(z_plane.time_to_bound(ray)).position","def illuminate(self, ray, hit, scene):\n # TODO A5 copy implementation from A4 and modify\n # material parameters need to be looked up by the uv's at the intersection point\n l = self.position - hit.point\n epsilon = 0.000001\n point = hit.point + l*epsilon\n shadow_ray = Ray(point, l, epsilon, 1)\n\n if (scene.intersect(shadow_ray).t > 1):\n\n # diffuse shading\n intensity = self.intensity\n position = self.position\n normal = hit.normal\n dist_to_source = np.linalg.norm(hit.point - position)\n diffuse_coeff = hit.material.lookup(hit.material.k_d, hit)\n v = (-1) * normalize(ray.direction)\n light_ray = normalize(position - hit.point)\n specular_coeff = hit.material.lookup(hit.material.k_s, hit)\n p = hit.material.lookup(hit.material.p, hit)\n\n # diffuse shading\n # diffuse_output = diffuse_coeff * (np.maximum(0, np.dot(normal, light_ray)) / (dist_to_source ** 2)) * intensity\n # specular shading\n shade_ray = Ray(hit.point, light_ray, epsilon)\n if (scene.intersect(shade_ray).t == np.inf):\n h = (v + light_ray) / np.linalg.norm(v + light_ray)\n specular_output = (diffuse_coeff + specular_coeff * ((np.dot(normal, h)) ** p)) * (\n np.maximum(0, np.dot(normal, light_ray)) / (dist_to_source ** 2)) * intensity\n return specular_output\n\n return vec([0, 0, 0])","def hitDetect(self, direction, solid):\n # Hit edge code not finished - A-Small-Being\n modX = self.x\n modY = self.y\n if direction == Direction.LEFT:\n modX -= 1\n elif direction == Direction.RIGHT:\n modX += 1\n elif direction == Direction.UP:\n modY -= 1\n elif direction == Direction.DOWN:\n modY += 1\n\n if (modX, modY) in solid:\n return True\n\n if modX == 0:\n #too far left\n pass\n elif modX == self.gameWindow.TILEWIDTH + 1:\n # Too far right\n pass\n elif modY == 0:\n # Too far up\n pass\n elif modY == self.gameWindow.TILEHEIGHT + 1:\n # Too far down\n pass\n else:\n # Fine\n return False\n return True","def collision_detection(p, poly):\r\n _eps = 0.00001\r\n _huge = sys.float_info.max\r\n _tiny = sys.float_info.min\r\n \r\n def rayintersectseg(p, edge):\r\n ''' takes a point p=Pt() and an edge of two endpoints a,b=Pt() of a line segment returns boolean\r\n '''\r\n a,b = edge\r\n if a.y > b.y:\r\n a,b = b,a\r\n if p.y == a.y or p.y == b.y:\r\n p = Pt(p.x, p.y + _eps)\r\n \r\n intersect = False\r\n \r\n if (p.y > b.y or p.y < a.y) or (\r\n p.x > max(a.x, b.x)):\r\n return False\r\n \r\n if p.x < min(a.x, b.x):\r\n intersect = True\r\n else:\r\n if abs(a.x - b.x) > _tiny:\r\n m_red = (b.y - a.y) / float(b.x - a.x)\r\n else:\r\n m_red = _huge\r\n if abs(a.x - p.x) > _tiny:\r\n m_blue = (p.y - a.y) / float(p.x - a.x)\r\n else:\r\n m_blue = _huge\r\n intersect = m_blue >= m_red\r\n return intersect\r\n \r\n def _odd(x): return x%2 == 1\r\n \r\n def ispointinside(p, poly):\r\n\r\n return _odd(sum(rayintersectseg(p, edge)\r\n for edge in poly.edges ))\r\n \r\n detection = ispointinside(p,poly)\r\n return detection","def ray_trace(x, y, poly):\n\n @vectorize([bool_(float64, float64)])\n def ray(x, y):\n # where xy is a coordinate\n n = len(poly)\n inside = False\n p2x = 0.0\n p2y = 0.0\n xints = 0.0\n p1x, p1y = poly[0]\n for i in range(n + 1):\n p2x, p2y = poly[i % n]\n if y > min(p1y, p2y):\n if y <= max(p1y, p2y):\n if x <= max(p1x, p2x):\n if p1y != p2y:\n xints = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x\n if p1x == p2x or x <= xints:\n inside = not inside\n p1x, p1y = p2x, p2y\n return inside\n\n return ray(x, y)","def _hitTest(self, point):\n point = self.CalcUnscrolledPosition(point)\n for displayKey in self._displayKeys.values():\n if displayKey.scaled.Contains(point):\n return displayKey\n return None","def closest_on_screen_point_optim(trajectory, viewpoint, yaw, gaze_on_screen):\n \n traj_angles = dp.world_to_angles_through_screen(trajectory, viewpoint, yaw) \n \n #pprint(traj_angles)\n\n dist, idx = closest_node_tree(traj_angles, gaze_on_screen)\n ml_screen_ref = traj_angles[idx] \n\n return(idx, ml_screen_ref)","def get_projection_point(self, point, plane, test=False):\n return point_on_plane_projection(point, plane, test=test)","def mesh_ray_collision(mesh: jnp.ndarray, origin: jnp.ndarray, direction: jnp.ndarray):\n collides, positions, distances = jax.vmap(\n lambda t: _triangle_ray_collision(t, origin, direction)\n )(mesh)\n idx = jnp.argmin(jnp.where(collides, distances, jnp.inf))\n return (\n jnp.any(collides),\n positions[idx],\n _triangle_normal(mesh[idx]),\n )","def get_object_at_location(cls, x, y):\n object_map_at_target_location = cls.query\\\n .filter_by(x=x, y=y).one_or_none()\n if not object_map_at_target_location:\n return None\n return object_map_at_target_location.get_real_object()","def line_intersection(p0_x, p0_y, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y):\n s10_x = p1_x - p0_x\n s10_y = p1_y - p0_y\n s32_x = p3_x - p2_x\n s32_y = p3_y - p2_y\n\n denom = s10_x * s32_y - s32_x * s10_y\n if denom == 0.0:\n return None # Collinear\n denomPositive = denom > 0\n\n s02_x = p0_x - p2_x\n s02_y = p0_y - p2_y\n s_numer = s10_x * s02_y - s10_y * s02_x\n if (s_numer < 0) == denomPositive:\n return None # No collision\n\n t_numer = s32_x * s02_y - s32_y * s02_x\n if (t_numer < 0) == denomPositive:\n return None # No collision\n\n if (s_numer > denom) == denomPositive or (t_numer > denom) == denomPositive:\n return 0 # No collision\n \n # Collision detected\n t = t_numer / denom\n i_x = p0_x + (t * s10_x)\n i_y = p0_y + (t * s10_y)\n\n return i_x, i_y","def findminpath(tab, gxtab, gytab, pixtab):\n\n pathdist = 2 # the number of points each points on a ray can related to on the previous ray\n pathdist_penalty = 0.3 # penalty of the difference of the pathdist\n pathpix_penalty = 2 # penalty of the difference of pixel values between the point and the previous point\n nray = tab.shape[1]\n\n #tab = np.hstack((tab,tab[:, 0].reshape(tab.shape[0], 1)))\n #pixtab = np.hstack((pixtab,pixtab[:, 0].reshape(pixtab.shape[0], 1)))\n #gxtab = np.hstack((gxtab,gxtab[:, 0].reshape(gxtab.shape[0], 1)))\n #gytab = np.hstack((gytab,gytab[:, 0].reshape(gytab.shape[0], 1)))\n\n tab = np.hstack((tab,tab,tab)) # horizontally stack the tab matrix to prepare for the filtering on the result\n pixtab = np.hstack((pixtab,pixtab,pixtab))\n gxtab = np.hstack((gxtab,gxtab,gxtab))\n gytab = np.hstack((gytab,gytab,gytab))\n\n tab = (tab - tab.min()) / (tab.max() - tab.min()) # noralize the tab matrix\n pixtab = (pixtab - pixtab.min()) / (pixtab.max() - pixtab.min()) * -1 # for we want to find the white contour of the cell so we multipy -1 on the pixtab\n # tab = tab / np.median(tab)\n # pixtab = pixtab / np.median(pixtab)\n path = np.zeros(tab.shape)\n path[:, 0] = np.array(range(0, tab.shape[0]))\n score = np.zeros(tab.shape)\n score[:, 1] = tab[:, 1]\n\n for i in range(1, tab.shape[1]):\n for j in range(tab.shape[0]):\n mins = np.Inf # record the min value of the ray\n minat = 0\n for k in range(-pathdist, pathdist+1):\n if(0 <= (j+k) and (j+k) < tab.shape[0]):\n s = pixtab[j, i]\n pixdiff = abs(pixtab[j, i] - pixtab[j+k, i-1])\n s += pixdiff * pathpix_penalty # two kinds of penalty\n s += abs(k) * pathdist_penalty\n s += score[j+k, i-1]\n\n if(s < mins):\n mins = s\n minat = j + k\n path[j, i] = minat\n score[j, i]= mins\n\n start = int(np.argmin(score[:, -1]))\n path = path.astype(np.int32)\n minpath = [start]\n for i in range(tab.shape[1]-1, 0, -1):\n minpath.append(path[minpath[-1], i])\n minpath = minpath[::-1]\n # print(len(minpath))\n minpath = savgol_filter(minpath, 15, 3) # apply a Savitzky-Golay filter to the raw minpath signal\n minpath = minpath[nray:nray*2] # cut the middle part of minpath whose length is nray\n return np.array(minpath).astype(np.int32)","def test_point_on_plane(self, point, plane):\n _dist = point.dot(plane[:3]) + plane[3]\n if _dist <= epsilon:\n print('OK => point on plane')\n else:\n print('NO => point not on plane')","def hit(self):","def _pickFull(self, context):\n rayObject = context.getPickingSegment(frame=self._getScenePrimitive())\n if rayObject is None:\n return None\n\n points = utils.segmentPlaneIntersect(\n rayObject[0, :3],\n rayObject[1, :3],\n planeNorm=self.getNormal(),\n planePt=self.getPoint())\n\n if len(points) == 1: # Single intersection\n if numpy.any(points[0] < 0.):\n return None # Outside volume\n z, y, x = int(points[0][2]), int(points[0][1]), int(points[0][0])\n\n data = self.getData(copy=False)\n if data is None:\n return None # No dataset\n\n depth, height, width = data.shape\n if z < depth and y < height and x < width:\n return PickingResult(self,\n positions=[points[0]],\n indices=([z], [y], [x]))\n else:\n return None # Outside image\n else: # Either no intersection or segment and image are coplanar\n return None","def get_hit_marker(self):\r\n return Marker((0, 0, 0), self._screen)","def GetPlane(plane):\r\n pass","def hit(self, other=None, push=False):\n laser = pygame.mixer.Sound('resources/Laser.wav')\n laser.set_volume(0.5)\n if not other:\n front_pos = \\\n [p + d for p, d in zip(self.pos, DIRECTIONS[self.rotation])]\n other = self.map.get(front_pos)\n assert other is not None, \"No robot in front!\"\n if push:\n other.pos = [p + d for p, d in\n zip(other.pos, DIRECTIONS[self.rotation])]\n # get the hit direction\n look_other = DIRECTIONS[other.rotation]\n look_self = DIRECTIONS[self.rotation]\n if look_other == look_self: # von hinten getroffen\n damage = DAMAGE[FROM_BEHIND]\n elif all(abs(x) != abs(y)\n for x, y in zip(look_other, look_self)): # seitlich\n damage = DAMAGE[FROM_SIDE]\n else: # frontal\n damage = DAMAGE[FROM_FRONT]\n\n other.health -= damage if not push else damage * 0.25\n\n if hasattr(other, 'take_damage_anim'):\n other.animator.play_animation(other.take_damage_anim)\n if self.speakers:\n self.speakers.play(laser)\n new_turn = \"{0}!{1};{2}\".format(self.pos, other.pos, damage)\n self._call_gamelog_callbacks(new_turn)","def hit(self, rect):\n \n # Find the hits at the current level\n hits = set(item for item in self.items if rect.contains(item.location))\n \n # Recursively check the lower quadrants\n if self.nw and rect.left < self.cx and rect.top < self.cy:\n hits |= self.nw.hit(rect)\n if self.sw and rect.left < self.cx and rect.bottom >= self.cy:\n hits |= self.sw.hit(rect)\n if self.ne and rect.right >= self.cx and rect.top < self.cy:\n hits |= self.ne.hit(rect)\n if self.se and rect.right >= self.cx and rect.bottom >= self.cy:\n hits |= self.se.hit(rect)\n \n return hits","def get_mouse_ray(self, context, event):\n region, rv3d = context.region, context.region_data\n coord = event.mouse_region_x, event.mouse_region_y\n ray_direction = view3d_utils.region_2d_to_vector_3d(region, rv3d, coord)\n ray_origin = view3d_utils.region_2d_to_origin_3d(region, rv3d, coord)\n return ray_origin, ray_direction","def intersection_segment_plane(segment, plane, epsilon=1e-6):\n pt1 = segment[0]\n pt2 = segment[1]\n p_cent = plane[0]\n p_norm = plane[1]\n\n v1 = subtract_vectors(pt2, pt1)\n dot = dot_vectors(p_norm, v1)\n\n if abs(dot) > epsilon:\n v2 = subtract_vectors(pt1, p_cent)\n fac = -dot_vectors(p_norm, v2) / dot\n if fac > 0. and fac < 1.:\n vec = scale_vector(v1, fac)\n return add_vectors(pt1, vec)\n return None\n else:\n return None","def goto_pt(self, pt):\n curr_xy = [self.state.x, self.state.y]\n target_xy = (pt[0], pt[1])\n dist = math.sqrt((curr_xy[0] - target_xy[0])**2\n + (curr_xy[1] - target_xy[1])**2)\n\n if dist > self.goto_thresh:\n self.controller.target_velocity = self.goto_vel\n steering, velocity = \\\n self.controller.compute_control(self.state, target_xy)\n self.data_handler.update_target(self.controller.target)\n return steering, velocity\n else:\n self.controller.target_velocity = 0.0\n steering = 0.0\n velocity = 0.0\n return steering, velocity","def pred_car_other_lane(self):\n other_lane = self.other_lane()\n\n for i in range(self.road.N):\n if self.road.cells[other_lane][(self.x + i + 1) % (self.road.N-1)] != -1:\n return self.road.cars[self.road.cells[other_lane][(self.x + i + 1) % (self.road.N-1)]]","def linesegment_plane_intersection(self, p0,p1,point,normal): # only returns lines...intersections through the segment end points are ignored\n\t\tp0dot=numpy.dot(p0-point,normal)\n\t\tp1dot=numpy.dot(p1-point,normal)\n\t\tif (p0dot>0 and p1dot<0) or (p0dot<0 and p1dot>0): \n\t\t\t# if the dot products have opposing signs, then the line intersects the plane\n\t\t\treturn True,p0+(p1-p0)*abs(p0dot)/(abs(p0dot)+abs(p1dot))\n\t\telse:\n\t\t\treturn False"],"string":"[\n \"def rayIntersection(self, ray):\\n #t = \\\"what we are trying to find\\\"\\n l = -ray.mDirection\\n l0 = ray.mOrigin\\n n = self.mNormal\\n p0 = self.mDistance * n\\n #p = l0 + l * t\\n\\n if l.dot(n) > 0:\\n v = p0 - l0\\n t = -(v.dot(n) / l.dot(n))\\n return t\\n\\n else:\\n return None\",\n \"def intersect(self, ray):\\n # TODO A5 (Step1) implement this function\\n # Copy your implementation from A4\\n # Then calculate uv coordinates, to be passed into the Hit initializer\\n vs = self.vs\\n\\n a = vs[0][0] - vs[1][0]\\n b = vs[0][1] - vs[1][1]\\n c = vs[0][2] - vs[1][2]\\n d = vs[0][0] - vs[2][0]\\n e = vs[0][1] - vs[2][1]\\n f = vs[0][2] - vs[2][2]\\n\\n ray_dir = ray.direction\\n ray_orig = ray.origin\\n\\n g = ray_dir[0]\\n h = ray_dir[1]\\n i = ray_dir[2]\\n j = vs[0][0] - ray_orig[0]\\n k = vs[0][1] - ray_orig[1]\\n l = vs[0][2] - ray_orig[2]\\n\\n M = a * (e * i - h * f) + b * (g * f - d * i) + c * (d * h - e * g)\\n\\n t = -(f * (a * k - j * b) + e * (j * c - a * l) + d *\\n (b * l - k * c)) / M\\n\\n if (t < ray.start or t > ray.end):\\n return no_hit\\n\\n gamma = (i * (a * k - j * b) + h * (j * c - a * l) + g *\\n (b * l - k * c)) / M\\n\\n if (gamma < 0 or gamma > 1):\\n return no_hit\\n\\n beta = (j * (e * i - h * f) + k * (g * f - d * i) +\\n l * (d * h - e * g)) / M\\n\\n if (beta < 0 or beta > 1 - gamma):\\n return no_hit\\n\\n P = ray_orig + t * ray_dir\\n\\n unit_normal = normalize(np.cross(vs[0] - vs[2], vs[1] - vs[2]))\\n\\n A = np.linalg.norm(np.cross(vs[1] - vs[0], vs[2] - vs[0])) / 2\\n areaA = np.linalg.norm(np.cross(vs[1] - P, vs[2] - P)) / 2\\n areaB = np.linalg.norm(np.cross(vs[0] - P, vs[2] - P)) / 2\\n areaC = np.linalg.norm(np.cross(vs[0] - P, vs[1] - P)) / 2\\n u = areaB / A\\n v = areaC / A\\n return Hit(t, P, unit_normal, vec([u, v]), self.material)\",\n \"def next_hit(self, ray):\\n hit_candidates = [(i.time_to_bound(ray), i) for i in self._bounds]\\n try:\\n # WARNING - A hard cut on 'times' smaller than 10^-9 is made to exclude\\n # a beam reinteracting with the same barrier. This cuts out any legitimate\\n # interactions closer than 1nm of the beam position.\\n return (sorted([(time, surface) for time, surface in hit_candidates\\n if time is not None and time > 1e-9 and all(\\n [b.contains(ray.propagate(time).position) for b in self._bounds\\n if b is not surface])])[0])\\n except IndexError:\\n return None\",\n \"def intersect(self, ray):\\n # TODO A5 (Step1) implement this function\\n # Copy your implementation from A4\\n # Then calculate uv coordinates, to be passed into the Hit initializer\\n D = ray.direction\\n E = ray.origin\\n C = self.center\\n R = self.radius\\n B = 2*np.dot(D, E-C)\\n A = np.dot(D, D)\\n min_t = ray.start\\n max_t = ray.end\\n\\n discriminant = B ** 2 - 4 * A * (np.dot(E-C, E-C)-R**2)\\n\\n if discriminant < 0:\\n return no_hit\\n\\n t0 = (-1*B - np.sqrt(discriminant)) / (2*A)\\n t1 = (-1*B + np.sqrt(discriminant)) / (2*A)\\n\\n if (t0 >= min_t and t0 <= max_t and t0 <= t1):\\n t = t0\\n elif (t1 >= min_t and t1 <= max_t):\\n t = t1\\n else:\\n return no_hit\\n\\n P = E + t * D\\n unit_normal = (P - C) / R\\n d_hat = normalize(P - C)\\n u = 0.5 + (np.arctan2(d_hat[0], d_hat[2])) / (2 * np.pi)\\n v = 0.5 + (np.arcsin(d_hat[1])) / np.pi\\n\\n return Hit(t, P, unit_normal, vec([u, v]), self.material)\",\n \"def intersectRay(self, ray):\\n # Ray Tracing from the Ground Up, pg. 367\\n a, b, c, d = self.a[0] - self.b[0], self.a[0] - self.c[0], ray.d[0], self.a[0] - ray.o[0]\\n e, f, g, h = self.a[1] - self.b[1], self.a[1] - self.c[1], ray.d[1], self.a[1] - ray.o[1]\\n i, j, k, L = self.a[2] - self.b[2], self.a[2] - self.c[2], ray.d[2], self.a[2] - ray.o[2]\\n\\n m, n, p = f * k - g * j, h * k - g * L, f * L - h * j\\n q, s = g * i - e * k, e * j - f * i\\n\\n denom = a * m + b * q + c * s\\n if denom < self.kEpsilon:\\n return None\\n\\n inv_denom = 1.0 / denom\\n\\n e1 = d * m - b * n - c * p\\n beta = e1 * inv_denom\\n\\n if 1.0 < beta or beta < 0.0:\\n return None\\n\\n r = e * L - h * i\\n e2 = a * n + d * q + c * r\\n gamma = e2 * inv_denom\\n\\n if 1.0 < gamma or gamma < 0.0:\\n return None\\n\\n e3 = a * p - b * r + d * s\\n t = e3 * inv_denom\\n\\n if t < self.kEpsilon:\\n return None\\n\\n return t\",\n \"def intersects(self, ray):\\n theta = 45\\n H = 512\\n W = 512\\n A = self.origin\\n B = Point(W, A.y, A.z)\\n C = Point(B.x, (int)(H * math.sin(theta * math.pi / 180)), (int)(H * math.cos(math.pi * theta / 180)))\\n D = Point(A.x, (int)(H * math.sin(theta * math.pi / 180)), (int)(H * math.cos(math.pi * theta / 180)))\\n vec3 = ray.direction * self.normal\\n if vec3 != 0:\\n vec1 = self.origin - ray.origin\\n vec2 = vec1 * self.normal\\n dist = vec2 / vec3\\n if dist > 0:\\n point_on_plane = ray.origin + dist * ray.direction\\n if A.x <= point_on_plane.x <= B.x and A.y <= point_on_plane.y <= D.y and B.z <= point_on_plane.z <= C.z:\\n #print A, B, C, D, point_on_plane\\n return dist\",\n \"def intersectsAB(self, ray):\\n v1 = ray.origin - self.pointA\\n v2 = self.pointB - self.pointA\\n v3 = Point(-ray.direction.y, ray.direction.x)\\n dot = v2.dot(v3)\\n if (abs(dot) < 0.000001):\\n return None\\n t1 = v2.cross(v1) / dot\\n t2 = v1.dot(v3) / dot\\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\\n return t1\\n return None\",\n \"def raySegmentIntersectAB(self, ray):\\n v1 = ray.origin - self.pointA\\n v2 = self.pointB - self.pointA\\n v3 = Point(-ray.direction.y, ray.direction.x)\\n dot = v2.dot(v3)\\n if (abs(dot) < 0.000001):\\n return None\\n t1 = v2.cross(v1) / dot\\n t2 = v1.dot(v3) / dot\\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\\n return t1\\n return None\",\n \"def intersect(self, ray):\\n # TODO A5 (Step3 and Step4) implement this function\\n # For step 4, check if uvs and normals are not None (respectively)\\n # If so, then interpolate them\\n\\n # batch_intersect returns t, beta, gamma, i\\n posns = self.posns\\n uvs = self.uvs\\n inds = self.inds\\n normals = self.normals\\n t, beta, gamma, i = batch_intersect(posns[inds[:, :]], ray)\\n if (t == np.inf):\\n return no_hit\\n vs = posns[inds[i, :]]\\n P = ray.origin + t * ray.direction\\n\\n if (t == np.inf):\\n return no_hit\\n else:\\n\\n alpha = 1 - beta - gamma\\n\\n if uvs is not None:\\n\\n uv0 = uvs[inds[i][0]]\\n uv1 = uvs[inds[i][1]]\\n uv2 = uvs[inds[i][2]]\\n\\n uv = alpha * uv0 + beta * uv1 + gamma * uv2\\n\\n else:\\n\\n A = np.linalg.norm(np.cross(vs[1] - vs[0], vs[2] - vs[0])) / 2\\n areaA = np.linalg.norm(np.cross(vs[1] - P, vs[2] - P)) / 2\\n areaB = np.linalg.norm(np.cross(vs[0] - P, vs[2] - P)) / 2\\n areaC = np.linalg.norm(np.cross(vs[0] - P, vs[1] - P)) / 2\\n u = areaB / A\\n v = areaC / A\\n uv = vec([u, v])\\n\\n if normals is not None:\\n\\n n0 = normals[inds[i][0]]\\n n1 = normals[inds[i][1]]\\n n2 = normals[inds[i][2]]\\n\\n unit_normal = normalize(alpha * n0 + beta * n1 + gamma * n2)\\n\\n else:\\n unit_normal = normalize(np.cross(vs[0] - vs[2], vs[1] - vs[2]))\\n\\n return Hit(t, P, unit_normal, uv, self.material)\",\n \"def intersection(self, ray):\\n d_proj = self._normal.dot(ray.d)\\n if abs(d_proj) < bounds.too_small:\\n return -1.0\\n s_proj = (self._origin - ray.o).dot(self._normal)\\n if d_proj * s_proj < 0.0:\\n # ray going away from plane\\n return -1.0\\n else:\\n return s_proj / d_proj\",\n \"def rayIntersection(self, ray):\\n\\n rotVect = ray.mDirection #math3d.VectorN(math.cos(num), - math.sin(num), 0)\\n\\n # this give all the lines (red green and blue at the moment)\\n tankPos = math3d.VectorN(ray.mOrigin[0], ray.mOrigin[1], 0)\\n linkPos = math3d.VectorN(200,200,0)\\n v = linkPos - tankPos\\n added = (tankPos + getPara(v, rotVect) + getPerp(v, rotVect))\\n added2 = tankPos + getPara(v, rotVect) #If the magnitude of this is minus the sphere origin is less than the radius you're in the sphere\\n added3 = tankPos + getPerp(v, rotVect)\\n added4 = tankPos + rotVect.normalized() * 200 #this is get point only change 200 to dist\\n\\n\\n test = added2 - self.mCenter #checks if in center\\n\\n\\n if test.magnitude() <= self.mRadius:\\n green = added2 - ray.mOrigin #this is Qpara\\n thing = (self.mSRadius - test.magnitude()**2) ** 0.5\\n t = (green.magnitude() - thing)\\n print(green.magnitude() - thing)\\n return t\\n else:\\n return None\\n\\n #print(test.magnitude(), self.mRadius)\\n #print(green.magnitude(), \\\"green\\\")\",\n \"def _get_intersection(self, ray):\\n\\n intersection = None\\n for obj in self.objects:\\n dist = obj.intersects(ray)\\n if dist is not None and \\\\\\n (intersection is None or dist < intersection[1]):\\n intersection = obj, dist\\n\\n return intersection\",\n \"def time_to_bound(self, ray):\\n incidence_cosine = dot(self._normal, ray.direction)\\n aplanarity = (self._position - ray.position).dot(self._normal)\\n if incidence_cosine == 0:\\n # Ray parallel to plane. If aplanarity also 0, ray is in the plane.\\n return None\\n time = aplanarity / incidence_cosine\\n return time if time > 0 else None\",\n \"def getIntersection(self, ray):\\n pass\",\n \"def intersect(self, plane, epsilon=0.00001):\\r\\n den = np.dot(self.direction, plane.normal)\\r\\n if math.fabs(den) < epsilon:\\r\\n return None\\r\\n\\r\\n result = (-plane.distance - np.dot(plane.normal, self.origin)) / den\\r\\n\\r\\n if result < 0.0:\\r\\n if result < -epsilon:\\r\\n return None\\r\\n result = 0.0\\r\\n return result\",\n \"def intersect(self, ray):\\n # TODO A5 copy your implementation from A4\\n surfaces = self.surfs\\n\\n min_t = np.inf\\n i = no_hit\\n\\n for s in surfaces:\\n intersect = s.intersect(ray)\\n if (intersect.t < min_t):\\n min_t = intersect.t\\n i = intersect\\n return i\",\n \"def intersects(self, ray):\\n sphere_to_ray = ray.origin - self.center\\n a = 1\\n b = 2 * ray.direction.dot_product(sphere_to_ray)\\n c = sphere_to_ray.dot_product(sphere_to_ray) - self.radius * self.radius\\n discriminant = b * b - 4 * a * c\\n\\n if discriminant >= 0:\\n dist = (-b - sqrt(discriminant)) / 2\\n if dist > 0:\\n return dist\\n\\n return None\",\n \"def HitTest(self, point, flags=0):\\r\\n \\r\\n w, h = self.GetSize()\\r\\n flags = 0\\r\\n \\r\\n if point.x < 0:\\r\\n flags |= TREE_HITTEST_TOLEFT\\r\\n if point.x > w:\\r\\n flags |= TREE_HITTEST_TORIGHT\\r\\n if point.y < 0:\\r\\n flags |= TREE_HITTEST_ABOVE\\r\\n if point.y > h:\\r\\n flags |= TREE_HITTEST_BELOW\\r\\n\\r\\n if flags:\\r\\n return None, flags\\r\\n \\r\\n if self._anchor == None:\\r\\n flags = TREE_HITTEST_NOWHERE\\r\\n return None, flags\\r\\n \\r\\n hit, flags = self._anchor.HitTest(self.CalcUnscrolledPosition(point), self, flags, 0)\\r\\n\\r\\n if hit == None: \\r\\n flags = TREE_HITTEST_NOWHERE\\r\\n return None, flags\\r\\n\\r\\n if not self.IsItemEnabled(hit):\\r\\n return None, flags\\r\\n\\r\\n return hit, flags\",\n \"def is_intersecting(self, ray):\\n\\n intersecting_point = self._sympy_plane.intersection(ray.sympy_line)[0]\\n\\n if 'x' in self._name:\\n\\n if self._within_y_bounds(intersecting_point.y) and self._within_z_bounds(intersecting_point.z):\\n return True, np.array(map(float, [intersecting_point.x, intersecting_point.y, intersecting_point.z]))\\n\\n\\n\\n elif 'y' in self._name:\\n\\n if self._within_x_bounds(intersecting_point.x) and self._within_z_bounds(intersecting_point.z):\\n return True, np.array(map(float, [intersecting_point.x, intersecting_point.y, intersecting_point.z]))\\n\\n\\n\\n elif 'z' in self._name:\\n\\n if self._within_y_bounds(intersecting_point.y) and self._within_x_bounds(intersecting_point.x):\\n return True, np.array(map(float, [intersecting_point.x, intersecting_point.y, intersecting_point.z]))\\n\\n return False, None\",\n \"def shoot_ray(self, row, col):\\n # Uses validate method to check if row,col are legal for ray entrance location\\n if not self.valid_ray(row, col):\\n return False\\n # creates ray object from row, col integers\\n ray = Ray(row, col)\\n # checks if atom is in front of entrance position\\n if not ray.can_continue(self.get_a_locations()):\\n self.mark_portal(ray.get_start())\\n if self.get_score() <= 0:\\n self.change_state(\\\"LOST\\\")\\n return None\\n # while there is no atom in front of ray and ray will not exit board --\\n while ray.can_continue(self.get_a_locations()):\\n ray.check_diags(self.get_a_locations())\\n # moves ray forward one space\\n ray.advance()\\n # if ray will exit board by advancing --\\n if not ray.on_board():\\n # adjusts score if entrance/exit do not match prior entrances/exits\\n self.mark_portal(ray.get_start(), ray.get_pos())\\n # changes state to lose if score is now <= 0\\n if self.get_score() <= 0:\\n self.change_state(\\\"LOST\\\")\\n # returns tuple of exit location\\n return tuple(ray.get_pos())\\n # if ray is blocked by atom --\\n if not ray.no_atom(self.get_a_locations()):\\n # changes state to lost if score is now <= 0\\n self.mark_portal(ray.get_start())\\n if self.get_score() <= 0:\\n self.change_state(\\\"LOST\\\")\\n return None\",\n \"def ray_segment_intersect(p_ray, d_ray, seg):\\n d_seg = seg[1] - seg[0]\\n\\n t_max = np.linalg.norm(d_seg)\\n\\n d_seg = d_seg / t_max\\n d_ray = d_ray / np.linalg.norm(d_ray)\\n\\n D = np.stack([d_ray, -d_seg], axis=1)\\n b = seg[0] - p_ray\\n\\n try:\\n T = np.linalg.solve(D, b)\\n except np.linalg.LinAlgError as e:\\n # D is a singular matrix, lines are parallel\\n return None\\n\\n # 0 <= T[1] < t_max because if the ray intersects perfectly with vertices then they will\\n # T[0] > 0 ray shoots only in one direction\\n # be included twice because they are the end and the beginning of a two segments\\n if 0 <= T[1] < t_max and T[0] > 0 and np.allclose(np.dot(D, T), b):\\n return seg[0] + d_seg * T[1]\\n else:\\n return None\",\n \"def intersection(self, line: AbstractLine) -> Optional[AbstractPoint]:\\n plane = Plane(self.__point_a,\\n self.__point_b - self.__point_a,\\n self.__point_c - self.__point_a)\\n\\n point = plane.intersection(line)\\n if point is not None:\\n if self.has_point(point):\\n return point\\n return None\",\n \"def intersects(self, ray):\\n def raySegmentIntersectAB(self, ray):\\n \\\"\\\"\\\"\\n recibes a ray. checks if it intersects the segment\\n dot: denominator. if dot = 0 they're paralel\\n t1: distance from origin to intersection\\n t2: intersection IN the segment\\n \\\"\\\"\\\"\\n v1 = ray.origin - self.pointA\\n v2 = self.pointB - self.pointA\\n v3 = Point(-ray.direction.y, ray.direction.x)\\n dot = v2.dot(v3)\\n if (abs(dot) < 0.000001):\\n return None\\n t1 = v2.cross(v1) / dot\\n t2 = v1.dot(v3) / dot\\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\\n return t1\\n return None\\n \\n def raySegmentIntersectCD(self, ray):\\n v1 = ray.origin - self.pointC\\n v2 = self.pointD - self.pointC\\n v3 = Point(-ray.direction.y, ray.direction.x)\\n dot = v2.dot(v3)\\n if (abs(dot) < 0.000001):\\n return None\\n t1 = v2.cross(v1) / dot\\n t2 = v1.dot(v3) / dot\\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\\n return t1\\n return None\\n \\n def raySegmentIntersectAC(self, ray):\\n v1 = ray.origin - self.pointA\\n v2 = self.pointC - self.pointA\\n v3 = Point(-ray.direction.y, ray.direction.x)\\n dot = v2.dot(v3)\\n if (abs(dot) < 0.000001):\\n return None\\n t1 = v2.cross(v1) / dot\\n t2 = v1.dot(v3) / dot\\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\\n return t1\\n return None\\n\\n def raySegmentIntersectBD(self, ray):\\n v1 = ray.origin - self.pointB\\n v2 = self.pointD - self.pointB\\n v3 = Point(-ray.direction.y, ray.direction.x)\\n dot = v2.dot(v3)\\n if (abs(dot) < 0.000001):\\n return None\\n t1 = v2.cross(v1) / dot\\n t2 = v1.dot(v3) / dot\\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\\n return t1\\n return None\\n \\n \\n minD = 9999\\n distance_AB = raySegmentIntersectAB(self, ray)\\n distance_CD = raySegmentIntersectCD(self, ray)\\n distance_AC = raySegmentIntersectAC(self, ray)\\n distance_BD = raySegmentIntersectBD(self, ray)\\n \\n if distance_AB is not None:\\n minD = distance_AB\\n \\n if distance_CD is not None:\\n if distance_CD < minD:\\n minD = distance_CD\\n \\n if distance_AC is not None:\\n if distance_AC < minD:\\n minD = distance_AC\\n \\n if distance_BD is not None:\\n if distance_BD < minD:\\n minD = distance_BD\\n\\n if minD is not None:\\n if minD != 9999:\\n return minD\\n return None\\n \\\"\\\"\\\"\\n minD = raySegmentIntersectBD(self, ray)\\n #print (minD)\\n return minD\\n \\\"\\\"\\\"\",\n \"def getRay(self, points, normed=False): # pragma: no cover\\n # to be overloaded by the child class.\\n return None\",\n \"def intersection(self, segment):\\n intersection = self.hyperplane.intersection(segment)\\n if intersection is not None and np.linalg.norm(intersection - self.closest_point_to(intersection)) < epsilon:\\n return intersection\\n\\n return None\",\n \"def hit(self):\\n return self._hit\",\n \"def intersection(self, ray):\\n \\n points = []\\n intersection_objects = []\\n for obj in self.objects:\\n intersection = obj.shape.intersection(ray)\\n if intersection != None:\\n for pt in intersection:\\n points.append(pt)\\n intersection_objects.append(obj)\\n \\n if len(points) == 0:\\n return None, None\\n return points, intersection_objects\",\n \"def hit(bx, by, r, px, py,h):\\n if bx >= px:\\n distance = bx - px\\n else:\\n distance = px - bx\\n if py<=by and by<=py+h and distance <= r:\\n return True\\n else:\\n return False\",\n \"def intersect(self,ray:Ray):\\n o = ray.o #ray origin\\n d = ray.d #ray destination\\n oc = o - self.center #vector from ray origin to center\\n b = 2*(oc*d)\\n c = oc*oc - self.r**2\\n disc = b**2-4*c\\n if disc<0:\\n return False,-1\\n else:\\n disc **=0.5\\n t0 = -b-disc\\n t1 = -b+disc\\n return True,max(t0,t1)\",\n \"def intersect(l: Line, p: Plane) -> Point:\\n if math.isclose((l.d * p.normal()), 0):\\n # If the line direction is perpendicular to the plane normal,\\n # the line and plane must be parallel.\\n return None\\n else:\\n # There exists a parameter t, which makes\\n # p.isInPlane(l.point(t)) == 0\\n # Let's find it.\\n # Initial guess\\n t1 = 1\\n p1 = l.point(t1)\\n d1 = distancePointPlane(p1, p)\\n t2 = 2\\n p2 = l.point(t2)\\n d2 = distancePointPlane(p2, p)\\n\\n # Calculate line through the two points (t,d)\\n a = (d2 - d1) / (t2 - t1)\\n b = d1 - a * t1\\n\\n # Find the t-value where d is zero\\n # 0 = at+b <=> t = -b/a\\n t = -b / a\\n print(\\\"parameter: {}\\\".format(t))\\n return l.point(t)\",\n \"def intersection_plane_plane_plane(plane1, plane2, plane3, epsilon=1e-6):\\n line = intersection_plane_plane(plane1, plane2, epsilon)\\n if not line:\\n return None\\n pt = intersection_line_plane(line, plane3, epsilon)\\n if pt:\\n return pt\\n return None\",\n \"def intersects(self, ray):\\n\\n sphere_to_ray = ray.origin - self.origin\\n b = 2 * ray.direction * sphere_to_ray\\n c = sphere_to_ray ** 2 - self.radius ** 2\\n discriminant = b ** 2 - 4 * c\\n\\n if discriminant >= 0:\\n dist = (-b - math.sqrt(discriminant)) / 2\\n if dist > 0:\\n return dist\",\n \"def intersectsRay(self, ray):\\n pass\",\n \"def hit(self, ray_, t_min, t_max):\\n raise NotImplemented(\\\"Override in subclass\\\")\",\n \"def get_closest_node(self, point, plane=None):\\n node = -1\\n best_dist = 1.e100\\n\\n if len(point) == 3:\\n # Seaching in 3d mesh\\n meshz = self.get_data_value('ELEVATION Z', 0)\\n for i in range(self.npoin3):\\n dist = (self.meshx[i]- point[0])**2 + \\\\\\n (self.meshy[i]- point[1])**2 + \\\\\\n (meshz[i]- point[2])**2\\n\\n if dist < best_dist:\\n best_dist = dist\\n node = i\\n\\n elif len(point) == 2:\\n if plane is None:\\n # Searching in a 2d mesh\\n for i in range(self.npoin2):\\n dist = (self.meshx[i]- point[0])**2 + \\\\\\n (self.meshy[i]- point[1])**2\\n\\n if dist < best_dist:\\n best_dist = dist\\n node = i\\n else:\\n # Searching in a given plane for the closest node\\n for i in range(plane*self.npoin2, (plane+1)*self.npoin2):\\n dist = (self.meshx[i]- point[0])**2 + \\\\\\n (self.meshy[i]- point[1])**2\\n\\n if dist < best_dist:\\n best_dist = dist\\n node = i\\n\\n else:\\n raise TelemacException(\\\\\\n \\\"Point should be 2d or 3d: {}\\\".format(point))\\n\\n return node\",\n \"def LinePlaneCollision(planeNormal, planePoint, rayDirection, rayPoint, epsilon=1e-12):\\n\\n ndotu = planeNormal.dot(rayDirection)\\n if abs(ndotu) < epsilon:\\n raise RuntimeError(\\\"no intersection or line is within plane\\\")\\n\\n w = rayPoint - planePoint\\n si = -planeNormal.dot(w) / ndotu\\n Psi = w + si * rayDirection + planePoint\\n return Psi\",\n \"def intersection_ray_ray_3d(ray1: Tuple[Vector, Vector],\\n ray2: Tuple[Vector, Vector], abs_tol=1e-10) -> \\\\\\nSequence[\\n Vector]:\\n # source: http://www.realtimerendering.com/intersections.html#I304\\n o1, p1 = ray1\\n d1 = (p1 - o1).normalize()\\n o2, p2 = ray2\\n d2 = (p2 - o2).normalize()\\n d1xd2 = d1.cross(d2)\\n denominator = d1xd2.magnitude_square\\n if math.isclose(denominator, 0., abs_tol=abs_tol):\\n # ray1 is parallel to ray2\\n return tuple()\\n else:\\n o2_o1 = o2 - o1\\n det1 = _determinant(o2_o1, d2, d1xd2)\\n det2 = _determinant(o2_o1, d1, d1xd2)\\n p1 = o1 + d1 * (det1 / denominator)\\n p2 = o2 + d2 * (det2 / denominator)\\n if p1.isclose(p2, abs_tol=abs_tol):\\n # ray1 and ray2 have an intersection point\\n return p1,\\n else:\\n # ray1 and ray2 do not have an intersection point,\\n # p1 and p2 are the points of closest approach on each ray\\n return p1, p2\",\n \"def current_navmesh(self):\\n source = self.transform.world_position.copy()\\n source.z += 1\\n\\n target = source.copy()\\n target.z -= 2\\n\\n result = self.physics.ray_test(target=target, source=source, mask=CollisionGroups.navmesh)\\n\\n if result is None:\\n return None\\n\\n return result.entity\",\n \"def ray_cast(self, max_distance):\\n\\t\\tray_angle = radians(self.rotation)\\n\\n\\t\\t# Sense objects\\n\\t\\tx, y = self.position\\n\\t\\tclosest = None\\n\\t\\tclosest_distance = float('inf')\\n\\t\\tfor obj in self.get_scene_objects():\\n\\t\\t\\tif not hasattr(obj, 'position') or obj is self:\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tobj_x, obj_y = obj.position\\n\\n\\t\\t\\t# Figure out what the angle of this object is\\n\\t\\t\\t# relative to self\\n\\t\\t\\tdelta_x = obj_x - x\\n\\t\\t\\tdelta_y = y - obj_y\\n\\t\\t\\tangle = atan2(delta_y, delta_x) - pi/2\\n\\n\\t\\t\\t# If the angle is acceptably in front of self\\n\\t\\t\\tif abs(angle - ray_angle) >= RAY_ANGLE_THRESHOLD:\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\tdist = self.distance_to(obj)\\n\\t\\t\\tif dist < closest_distance:\\n\\t\\t\\t\\tclosest = obj\\n\\t\\t\\t\\tclosest_distance = dist\\n\\n\\t\\tif closest is not None:\\n\\t\\t\\tif closest_distance <= max_distance:\\n\\t\\t\\t\\treturn closest\\n\\t\\t\\t# Object is there, but not close enough\\n\\t\\t\\treturn None\\n\\n\\t\\t# Sense boundary\\n\\n\\t\\t# Divide the max_distance into components\\n\\t\\t# based on the ray angle\\n\\t\\tmax_x = max_distance * sin(ray_angle)\\n\\t\\tmax_y = max_distance * cos(ray_angle)\\n\\n\\t\\t# Add the max_x and max_y to the current position\\n\\t\\tmax_x = x - max_x\\n\\t\\tmax_y = y - max_y\\n\\n\\t\\t# Check if either component is out of a boundary\\n\\t\\tif max_x < 0:\\n\\t\\t\\treturn LEFT_BOUNDARY\\n\\t\\telif max_x > self.get_screen_width():\\n\\t\\t\\treturn RIGHT_BOUNDARY\\n\\t\\telif max_y < 0:\\n\\t\\t\\treturn TOP_BOUNDARY\\n\\t\\telif max_y > self.get_screen_height():\\n\\t\\t\\treturn BOTTOM_BOUNDARY\\n\\n\\t\\t# Nothing found\\n\\t\\treturn None\",\n \"def hitTest( a, b ):\\n r = a.radius + b.radius\\n x = abs( a.x - b.x )\\n y = abs( a.y - b.y )\\n if x <= r and y <= r and x*x + y*y <= r*r:\\n return 1\\n return 0\",\n \"def pick(self, start, direction, mat):\\n new_mat = np.dot(\\n np.dot(mat, self.translation_matrix),\\n np.linalg.inv(self.scaling_matrix)\\n )\\n\\n results = self.aabb.ray_hit(start, direction, mat)\\n return results\",\n \"def ray_status(ray, points, nodes):\\n container = find_container(ray, nodes)\\n \\n # Handle special case of last step where ray is hitting the world node\\n root = nodes[0].root\\n if container == root and len(nodes) == 1:\\n status = root, None, root\\n return status\\n\\n if nodes[0] == container:\\n surface_node = nodes[0]\\n to_node = nodes[1]\\n else:\\n surface_node = nodes[0]\\n to_node = nodes[0]\\n status = container, to_node, surface_node\\n return status\",\n \"def HitTest(self, point, flags=0):\\r\\n\\r\\n w, h = self.GetSize()\\r\\n column = -1\\r\\n\\r\\n if not isinstance(point, wx.Point):\\r\\n point = wx.Point(*point)\\r\\n\\r\\n if point.x < 0:\\r\\n flags |= wx.TREE_HITTEST_TOLEFT\\r\\n if point.x > w:\\r\\n flags |= wx.TREE_HITTEST_TORIGHT\\r\\n if point.y < 0:\\r\\n flags |= wx.TREE_HITTEST_ABOVE\\r\\n if point.y > h:\\r\\n flags |= wx.TREE_HITTEST_BELOW\\r\\n if flags:\\r\\n return None, flags, column\\r\\n\\r\\n if not self._anchor:\\r\\n flags = wx.TREE_HITTEST_NOWHERE\\r\\n column = -1\\r\\n return None, flags, column\\r\\n \\r\\n hit, flags, column = self._anchor.HitTest(self.CalcUnscrolledPosition(point), self, flags, column, 0)\\r\\n if not hit:\\r\\n flags = wx.TREE_HITTEST_NOWHERE\\r\\n column = -1\\r\\n return None, flags, column\\r\\n \\r\\n return hit, flags, column\",\n \"def trace(self, ray): # type: (Ray) -> Vector\\n hit_object = None\\n t = numpy.inf\\n\\n for scene_object in self.scene.shapes:\\n t0 = scene_object.intersect(ray)\\n if t0 < t:\\n t = t0\\n hit_object = scene_object\\n\\n # if there were no intersections, then return the background colour\\n if t == numpy.inf:\\n return self.scene.camera.background\\n\\n hit_point = ray.origin + ray.direction * t\\n normal = hit_object.normal(hit_point)\\n luminance = 0.0\\n\\n # perform shading calculations\\n for light in self.scene.lights:\\n hit_point_to_light = (light.centre - hit_point).normal\\n\\n #check whether this light contributes to the shading\\n in_shadow = False\\n for shadower in self.scene.shapes:\\n # we don't want to test against itself\\n if shadower == hit_object:\\n continue\\n shadow_ray = Ray(hit_point + normal * 0.0001, hit_point_to_light)\\n if shadower.intersect(shadow_ray) < numpy.inf:\\n in_shadow = True\\n break\\n if in_shadow:\\n continue\\n\\n # super simple lambertian lighting model\\n luminance += hit_point_to_light.dot(normal) * light.power\\n\\n # calculate shaded colour - luminance may be over one if there are multiple light sources\\n # normally this would be dealt with by HDR and tone mapping but is just clipped\\n # in demo ray tracers\\n object_colour = hit_object.material.colour * min(luminance, 1.0)\\n\\n # calculate reflection colour if material has reflectance\\n if hit_object.material.reflectance != 0.0 and ray.depth != self.scene.camera.depth:\\n reflected_direction = (ray.direction - normal * 2 * (ray.direction.dot(normal))).normal\\n # we need to 'translate' the reflection vector away from the hitpoint otherwise\\n # we risk intersecting the original hit point again which causes artifacts in the reflection\\n reflected_ray = Ray(hit_point + reflected_direction * 0.0001, reflected_direction, ray.depth + 1)\\n reflection_colour = self.trace(reflected_ray)\\n\\n # interpolate shaded colour and reflected colour based on reflectance\\n return Vector(*[lerp(object_colour.data[i], reflection_colour.data[i], hit_object.material.reflectance) for i in range(3)])\\n\\n return object_colour\",\n \"def ray(self):\\n return self._ray\",\n \"def LinePlaneIntersection(line, plane):\\n plane = rhutil.coerceplane(plane, True)\\n line_points = rhutil.coerce3dpointlist(line, True)\\n line = Rhino.Geometry.Line(line_points[0], line_points[1])\\n rc, t = Rhino.Geometry.Intersect.Intersection.LinePlane(line, plane) \\n if not rc: return scriptcontext.errorhandler()\\n return line.PointAt(t)\",\n \"def time_to_bound(self, ray):\\n qr_a = ray.direction.dot(ray.direction)\\n qr_b = 2. * (ray.position - self._center).dot(ray.direction)\\n qr_c = np.linalg.norm(ray.position - self._center)**2 - self._radius**2\\n radical_arg = qr_b**2 - (4. * qr_a * qr_c)\\n try:\\n if qr_b < 0:\\n quadratic = (-qr_b - sqrt(radical_arg)) / 2.\\n else:\\n quadratic = (-qr_b + sqrt(radical_arg)) / 2.\\n if quadratic != 0.0:\\n return min((i for i in (quadratic / qr_a, qr_c / quadratic) if i > 0))\\n except ValueError:\\n # Root is imaginary. Pass this to return None.\\n pass\\n return None\",\n \"def get_atom_hit(self):\\r\\n return Marker((0, 128, 0), self._screen)\",\n \"def intersect_plane(L, plane):\\n \\n # Line U, V\\n # Plane N n\\n # (VxN-nU:U.N)\\n # Note that this is in homogeneous coordinates.\\n # intersection of plane (n,p) with the line (v,p)\\n # returns point and line parameter\\n \\n \\n den = np.dot(L.w, plane.n)\\n \\n if abs(den) > (100*_eps):\\n P = -(np.cross(L.v, plane.n) + plane.p * L.w) / den\\n p = (np.cross(L.v, plane.n) - plane.p * L.w) / den\\n \\n P = L.pp\\n t = np.dot( P-p, N)\\n return namedtuple('intersect_plane', 'p t')(P, t)\\n else:\\n return None\",\n \"def _next_hit(self, elements):\\n hits = ((item, item.next_hit(self._ray)) for item in elements)\\n try:\\n return sorted(\\n [(hit[0], hit[1], item) for item, hit in hits if hit is not None])[0]\\n except IndexError:\\n return None\",\n \"def point_of_intersection(l, pz=distance):\\r\\n # Must fix the error here. Right now, any vector can have a point in the plane.\\r\\n # Must make it so that only vectors pointing in the planes direction has a point there\\r\\n # Can be done by checking whether d is positive or not.\\r\\n # This is to prevent vectors that point away from the detector to be counted\\r\\n # The definitions below assume that the detector is centred in the origin and its length is oriented along the z-axis.\\r\\n p0 = np.array([0,0,pz]) # Point on the plane\\r\\n l0 = np.array([0,0,0]) # Point on the line\\r\\n n = np.array([0,0,1]) # Normal vector of the plane\\r\\n d = np.dot(p0-l0, n)/np.dot(l, n)\\r\\n point = [i*d for i in l]\\r\\n return point\",\n \"def shoot_ray(self, entry_x, entry_y):\\r\\n\\r\\n # check to make sure entry_x and entry_y are valid\\r\\n if (entry_x in [0, 9] or entry_y in [0, 9]) and \\\\\\r\\n self._board.get_board_item(entry_x, entry_y) != \\\"o\\\":\\r\\n\\r\\n exit_tup = self._board.find_exit(entry_x, entry_y)\\r\\n # returned 0 if hit\\r\\n if exit_tup == 0:\\r\\n # decrement entry only if not visited\\r\\n marker = self.get_hit_marker()\\r\\n circle_tuple = self.calculate_entry_exit(entry_y, entry_x)\\r\\n marker.update_center(circle_tuple)\\r\\n points = self._player.add_entry_exit((entry_x, entry_y), marker,\\r\\n (entry_x, entry_y))\\r\\n self._stats.dec_player_score(points)\\r\\n return \\\"Hit\\\"\\r\\n elif exit_tup == 1:\\r\\n # decrement entry only if not visited\\r\\n marker = self.get_reflect_marker()\\r\\n circle_tuple = self.calculate_entry_exit(entry_y, entry_x)\\r\\n marker.update_center(circle_tuple)\\r\\n points = self._player.add_entry_exit((entry_x, entry_y), marker,\\r\\n (entry_x, entry_y))\\r\\n\\r\\n self._stats.dec_player_score(points)\\r\\n\\r\\n return \\\"reflect\\\"\\r\\n else:\\r\\n # decrement both entry and exit if not already visited\\r\\n marker = self.get_color_marker()\\r\\n exit_x, exit_y = exit_tup\\r\\n circle_entry = self.calculate_entry_exit(entry_y, entry_x)\\r\\n circle_exit = self.calculate_entry_exit(exit_y, exit_x)\\r\\n marker.update_center(circle_entry, circle_exit)\\r\\n points = self._player.add_entry_exit((entry_x, entry_y),\\r\\n marker, exit_tup)\\r\\n\\r\\n self._stats.dec_player_score(points)\\r\\n return exit_tup\\r\\n else:\\r\\n # returns false if the shoot_ray point is invalid\\r\\n return \\\"Bad shot\\\"\",\n \"def getClosestPointFromLine(origin, ray, point):\\n # calculate the difference vector\\n delta = point-origin\\n # norm the ray\\n ray /= np.linalg.norm(ray, axis=-1)[..., None]\\n # calculate the scale product\\n factor = np.sum(ray*delta, axis=-1)\\n try:\\n return origin + factor[:, None] * ray\\n except IndexError:\\n return origin + factor * ray\",\n \"def reflect(self, ray):\\n normal = self.normal(ray.position)\\n if normal.dot(ray.direction) > 0:\\n normal = -normal\\n return Ray(\\n ray.direction - 2 * dot(ray.direction, normal) * normal, ray.position)\",\n \"def ray(self, pixel):\\n # Ensure pixel is in homogenous coordinates\\n if len(pixel) == 2:\\n pixel = np.vstack((pixel, [1]))\\n\\n ray = project(self._camera.P_pinv, pixel.astype(np.float32))\\n assert ray.shape == (4, 1)\\n\\n return self._camera.center, ray\",\n \"def intersection_line_plane(line, plane, epsilon=1e-6):\\n pt1 = line[0]\\n pt2 = line[1]\\n p_cent = plane[0]\\n p_norm = plane[1]\\n\\n v1 = subtract_vectors(pt2, pt1)\\n dot = dot_vectors(p_norm, v1)\\n\\n if abs(dot) > epsilon:\\n v2 = subtract_vectors(pt1, p_cent)\\n fac = -dot_vectors(p_norm, v2) / dot\\n vec = scale_vector(v1, fac)\\n return add_vectors(pt1, vec)\\n else:\\n return None\",\n \"def ray_at(self, O, t):\\n point = self.float_mul(t).plus(O)\\n return point\",\n \"def _hit_span_get(self):\\n try:\\n return self.hit_end - self.hit_start\\n except TypeError: # triggered if any of the coordinates are None\\n return None\",\n \"def ray_intersect_triangle(origin, direction, triangle, use_planes=False):\\n origin = np.array(origin)\\n direction = np.array(direction)\\n if len(direction.shape) == 1:\\n direction = direction.reshape(1, *direction.shape)\\n return_single = True\\n else:\\n return_single = False\\n triangle = np.array(triangle)\\n if len(triangle.shape) == 2:\\n triangle = triangle.reshape(1, *triangle.shape)\\n\\n v0 = triangle[..., 0, :]\\n v1 = triangle[..., 1, :]\\n v2 = triangle[..., 2, :]\\n u = v1 - v0\\n v = v2 - v0\\n normal = np.cross(u, v)\\n b = np.inner(normal, direction)\\n a = my_inner(normal[..., None, :], v0[..., None, :] - origin[None, ..., :])\\n\\n rI = a / b\\n # ray is parallel to the plane\\n rI[(b == 0.0)*(a != 0.0)] = np.nan\\n # ray is parallel and lies in the plane\\n rI[(b == 0.0)*(a == 0.0)] = 0\\n\\n # check whether the intersection is behind the origin of the ray\\n rI[rI < 0.0] = np.nan\\n\\n if not use_planes:\\n w = origin + rI[..., None] * direction - v0[..., None, :]\\n denom = my_inner(u, v) * my_inner(u, v) - my_inner(u, u) * my_inner(v, v)\\n\\n si = (my_inner(u, v)[..., None] * my_inner(w, v[..., None, :]) - my_inner(v, v)[..., None] * my_inner(w, u[..., None, :])) / denom[:, None]\\n rI[((si < 0)+(si > 1.0)).astype(bool)] = np.nan\\n\\n ti = (my_inner(u, v)[..., None] * my_inner(w, u[..., None, :]) - my_inner(u, u)[..., None] * my_inner(w, v[..., None, :])) / denom[:, None]\\n rI[((ti < 0.0) + (si + ti > 1.0)).astype(bool)] = np.nan\\n\\n def nanargmin(a, axis):\\n from numpy.lib.nanfunctions import _replace_nan\\n a, mask = _replace_nan(a, np.inf)\\n res = np.argmin(a, axis=axis)\\n return res\\n\\n index = nanargmin(rI, axis=0)\\n rI = rI[index, np.arange(len(index))]\\n point = origin + rI[..., None] * direction\\n\\n if return_single:\\n return point[0]\\n return point\",\n \"def intersection(self, segment):\\n p0, p1 = segment.p0, segment.p1\\n\\n # x = t*(p1 - p0) + p0\\n # n'*(x - origin) = 0\\n # combine to get\\n # n'*(t*(p1-p0) + p0 - origin) = 0\\n # solve for t\\n\\n v = p1 - p0\\n w = p0 - self.origin\\n t = -np.dot(self.normal, w)/np.dot(self.normal, v)\\n\\n if 0-epsilon <= t <= 1+epsilon:\\n return t*(p1-p0) + p0\\n else:\\n return None\",\n \"def simpleObjPickRoad(obj, roads):\\n # in here the obj (either union or terrace) consists of one building\\n fittestRid = -1\\n accessPoint = Point(0, 0)\\n\\n findRoad = False\\n\\n for road in roads:\\n reference = road.geom.project(obj.centroid)\\n tempAccessPoint = road.geom.interpolate(reference)\\n PointC = (obj.centroid.x, obj.centroid.y)\\n PointD = (tempAccessPoint.x, tempAccessPoint.y)\\n lineCD = LineString((PointC, PointD))\\n\\n if type(obj) == pg_read.Union:\\n # now we are using a union\\n uid = obj.id\\n cur.execute(\\\"select * from unions \\\\\\n where st_intersects(geom, st_geomfromtext('%s', 27700)) \\\\\\n and uid != %d\\\" % (lineCD.wkt, uid)) # NOQA\\n results = cur.fetchall()\\n if not results:\\n # which means no other unions intersects lineCD\\n findRoad = True\\n fittestRid = road.id\\n accessPoint = tempAccessPoint\\n break\\n else:\\n # which means we are using a terrace\\n tid = obj.id\\n cur.execute(\\\"select * from terraces \\\\\\n where st_intersects(geom, st_geomfromtext('%s', 27700)) \\\\\\n and tid != %d\\\" % (lineCD.wkt, tid)) # NOQA\\n results = cur.fetchall()\\n if not results:\\n # which means no other terraces intersects lineCD\\n findRoad = True\\n fittestRid = road.id\\n accessPoint = tempAccessPoint\\n break\\n\\n if findRoad:\\n # if findRoad == True:\\n return fittestRid, accessPoint\\n else:\\n # which means findRoad == False\\n # I know it's sad, but we need to have default option here\\n # we use the roads[0] as accessRoad anyway\\n road = roads[0]\\n reference = road.geom.project(obj.centroid)\\n fittestRid = road.id\\n accessPoint = road.geom.interpolate(reference)\\n return fittestRid, accessPoint\",\n \"def trace(self):\\n\\n \\n assert self.scene != None, \\\"The photon's scene variable is not set.\\\"\\n \\n intersection_points, intersection_objects = self.scene.intersection(self.ray)\\n\\n \\\"\\\"\\\"\\n #DIAGNOSTICS\\n print \\\"\\\\nnew\\\\n\\\"\\n print self.position, self.direction, \\\"\\\\n\\\"\\n print intersection_points, \\\"\\\\n\\\"\\n for i in range(0, len(intersection_objects)):\\n print \\\"Object: \\\", intersection_objects[i].name, \\\" - Intersection: \\\", intersection_points[i]\\n \\\"\\\"\\\"\\n \\n assert intersection_points != None, \\\"The ray must intersect with something in the scene to be traced.\\\"\\n \\n if self.container is None:\\n self.container = self.scene.container(self)\\n assert self.container != None, \\\"Container of ray cannot be found.\\\"\\n \\n #import pdb; pdb.set_trace()\\n #import pudb; pudb.set_trace()\\n intersection_points, intersection_objects = Scene.sort(intersection_points, intersection_objects, self, container=self.container, show_log=self.show_log)\\n \\n # find current intersection point and object -- should be zero if the list is sorted!\\n intersection = closest_point(self.position, intersection_points)\\n for i in range(0,len(intersection_points)):\\n if list(intersection_points[i]) == list(intersection):\\n index = i\\n break\\n \\n #import pdb; pdb.set_trace()\\n intersection_object = intersection_objects[index]\\n assert intersection_object != None, \\\"No intersection points can be found with the scene.\\\"\\n \\n \\n \\\"\\\"\\\"\\n #DIAGNOSTICS\\n print \\\"\\\\n\\\", intersection, \\\"\\\\n\\\"\\n print intersection_object.name \\n \\\"\\\"\\\" \\n \\n \\n # Reached scene boundaries?\\n if intersection_object is self.scene.bounds:\\n self.active = False\\n self.previous_container = self.container\\n self.container = self.scene.bounds\\n return self\\n\\n\\n # Reached a RayBin (kind of perfect absorber)?\\n if isinstance(intersection_object, RayBin):\\n self.active = False\\n self.previous_container = self.container\\n self.container = self.scene.bounds\\n return self\\n \\n \\n # Here we trace the ray through a Coating\\n if isinstance(self.container, Coating):\\n normal = intersection_object.shape.surface_normal(self.ray)\\n self = self.container.material.trace(self, normal, separation(self.position, intersection))\\n self.exit_device = self.container\\n self.previous_container = self.container\\n self.container = self.scene.container(self)\\n return self\\n \\n \\n # Here we determine if the Coating has been hit\\n if isinstance(intersection_object, Coating) and intersection_object.shape.on_surface(self.position):\\n self.previous_container = self.container\\n self.container = intersection_object\\n self.exit_device = intersection_object\\n assert self.exit_device != self.scene.bounds, \\\"The object the ray hit before hitting the bounds is the bounds, this can't be right.\\\"\\n return self\\n \\n \\n # Here we trace the ray through a Material\\n self = self.container.material.trace(self, separation(self.position, intersection))\\n \\n \\n # Lost in material?\\n # Photon has been re-absorbed but NOT re-emitted, i.e. is inactive\\n if not self.active:\\n #01/04/10: Unification --> Next two lines came from older Trace version\\n self.exit_device = self.container\\n self.exit_material = self.container.material\\n return self \\n \\n # Reaches interface\\n # Photon has been re-absorbed AND re-emitted, i.e. is still active\\n ray_on_surface = intersection_object.shape.on_surface(self.position)\\n if not ray_on_surface: \\n self.exit_device = self.container\\n return self\\n \\n # Ray has reached a surface of some description, increment the intersection counter\\n self.intersection_counter += 1\\n \\n # If we reach an reflective material then we don't need to follow \\n # this logic we can just return\\n if ray_on_surface and isinstance(intersection_object, Coating):\\n self.previous_container = self.container\\n self.container = intersection_object\\n self.exit_device = intersection_object\\n return self\\n \\n # KARLG NEW CODE HERE\\n #import pudb; pudb.set_trace()\\n if isinstance(intersection_object, Face):\\n self.exit_device = intersection_object\\n \\n # Now change the properties of the photon accoring to what your surface does\\n random_number = np.random.random_sample()\\n if random_number < intersection_object.reflectivity:\\n # Reflected\\n self.direction = reflect_vector(intersection_object.shape.surface_normal(self.ray), self.direction)\\n elif random_number < intersection_object.reflectivity + intersection_object.transmittance:\\n # Transmitted\\n pass\\n else:\\n # Loss\\n self.active = False\\n return self\\n \\n # Fresnel details\\n normal = intersection_object.shape.surface_normal(self.ray)\\n rads = angle(normal, self.direction)\\n \\n # material-air or material-material interface\\n # Are there duplicates intersection_points that are equal to the ray position?\\n same_pt_indices = []\\n for i in range(0,len(intersection_points)):\\n if cmp_points(self.position, intersection_points[i]):\\n same_pt_indices.append(i)\\n assert len(same_pt_indices) < 3, \\\"An interface can only have 2 or 0 common intersection points.\\\"\\n \\n initialised_internally = None\\n \\n if len(same_pt_indices) == 2:\\n intersection_object = self.container\\n \\n if self.container == intersection_object:\\n \\n # hitting internal interface -- for the case we are at an material-material interface (i.e. not travelling through air)\\n initialised_internally = True\\n \\n if len(same_pt_indices) == 2:\\n \\n for obj in intersection_objects:\\n if obj.shape.on_surface(intersection) and obj != self.container:\\n #if obj != self.container:\\n next_containing_object = obj\\n \\n \\n else:\\n # hitting internal interface -- for the case we are not at an interface\\n next_containing_object = self.scene.container(self)\\n \\n assert self.container != next_containing_object, \\\"The current container cannot also be the next containing object after the ray is propagated.\\\"\\n \\n # Fresnel details\\n normal = intersection_object.shape.surface_normal(self.ray)\\n rads = angle(normal, self.direction)\\n if self.polarisation == None:\\n reflection = fresnel_reflection(rads, self.container.material.refractive_index, next_containing_object.material.refractive_index)\\n else:\\n reflection = fresnel_reflection_with_polarisation(normal, self.direction, self.polarisation, self.container.material.refractive_index, next_containing_object.material.refractive_index)\\n \\n else:\\n # hitting external interface\\n initialised_internally = False \\n \\n \\n if len(same_pt_indices) == 2:\\n for obj in intersection_objects:\\n if obj != self.container:\\n intersection_object = obj\\n next_containing_object = obj\\n else:\\n next_containing_object = intersection_object\\n \\n #import pdb; pdb.set_trace()\\n normal = intersection_object.shape.surface_normal(self.ray)\\n rads = angle(normal, self.direction)\\n if self.polarisation == None:\\n reflection = fresnel_reflection(rads, self.container.material.refractive_index, next_containing_object.material.refractive_index)\\n else:\\n reflection = fresnel_reflection_with_polarisation(normal, self.direction, self.polarisation, self.container.material.refractive_index, next_containing_object.material.refractive_index)\\n \\n if isinstance(next_containing_object, Collector):\\n # If the photon hits an interface with e.g. a cell index-matched to it, then no reflection is to occur at this interface.\\n reflection = 0.\\n \\n if np.random.random_sample() < reflection:\\n # photon is reflected\\n before = copy(self.direction)\\n self.direction = reflect_vector(normal, self.direction)\\n ang = angle(before, self.direction)\\n \\n if self.polarisation != None:\\n \\n #import pdb; pdb.set_trace()\\n if cmp_floats(ang, np.pi):\\n # Anti-parallel\\n self.polarisation = self.polarisation\\n else:\\n # apply the rotation transformation the photon polarisation which aligns the before and after directions\\n R = rotation_matrix_from_vector_alignment(before, self.direction)\\n self.polarisation = transform_direction(self.polarisation, R)\\n \\n assert cmp_floats(angle(self.direction, self.polarisation), np.pi/2), \\\"Exit Pt. #1: Angle between photon direction and polarisation must be 90 degrees: theta=%s\\\" % str(np.degrees(angle(self.direction, self.polarisation)))\\n \\n self.propagate = False\\n self.exit_device = self.container\\n \\n # invert polaristaion if n1 < n2\\n if self.container.material.refractive_index < next_containing_object.material.refractive_index:\\n \\n if self.polarisation != None:\\n \\n if cmp_floats(ang, np.pi):\\n # Anti-parallel\\n self.polarisation = self.polarisation * -1.\\n else:\\n # apply the rotation transformation the photon polarisation which aligns the before and after directions\\n R = rotation_matrix_from_vector_alignment(before, self.direction)\\n self.polarisation = transform_direction(self.polarisation, R)\\n \\n assert cmp_floats(angle(self.direction, self.polarisation), np.pi/2), \\\"Exit Pt. #2: Angle between photon direction and polarisation must be 90 degrees: theta=%s\\\" % str(angle(self.direction, self.polarisation))\\n \\n if self.exit_device == self.scene.bounds or self.exit_device == None:\\n self.exit_device = intersection_object\\n assert self.exit_device != self.scene.bounds, \\\"The object the ray hit before hitting the bounds is the bounds, this can't be right\\\"\\n return self\\n else:\\n # photon is refracted through interface\\n self.propagate = True\\n before = copy(self.direction)\\n ang = angle(before, self.direction)\\n if initialised_internally:\\n if not isinstance(next_containing_object, Collector):\\n self.direction = fresnel_refraction(normal, self.direction, self.container.material.refractive_index, next_containing_object.material.refractive_index )\\n \\n if self.polarisation != None:\\n if cmp_floats(ang, np.pi):\\n # Anti-parallel\\n self.polarisation = self.polarisation\\n else:\\n # apply the rotation transformation the photon polarisation which aligns the before and after directions\\n R = rotation_matrix_from_vector_alignment(before, self.direction)\\n self.polarisation = transform_direction(self.polarisation, R)\\n assert cmp_floats(angle(self.direction, self.polarisation), np.pi/2), \\\"Exit Pt. #3: Angle between photon direction and polarisation must be 90 degrees: theta=%s\\\" % str(angle(self.direction, self.polarisation))\\n \\n self.exit_device = self.container #LSC is the exit_device\\n self.previous_container = self.container\\n self.container = next_containing_object #Bounds is the container\\n return self\\n else:\\n if not isinstance(next_containing_object, Collector):\\n self.direction = fresnel_refraction(normal, self.direction, self.container.material.refractive_index, intersection_object.material.refractive_index )\\n \\n if self.polarisation != None:\\n \\n if cmp_floats(ang, np.pi):\\n # Anti-parallel\\n self.polarisation = self.polarisation\\n else:\\n # apply the rotation transformation the photon polarisation which aligns the before and after directions\\n R = rotation_matrix_from_vector_alignment(before, self.direction)\\n self.polarisation = transform_direction(self.polarisation, R)\\n # apply the rotation transformation the photon polarisation which aligns the before and after directions\\n\\n assert cmp_floats(angle(self.direction, self.polarisation), np.pi/2), \\\"Exit Pt. #4: Angle between photon direction and polarisation must be 90 degrees: theta=%s\\\" % str(angle(self.direction, self.polarisation))\\n \\n # DJF 13.5.2010: This was crashing the statisical collection because it meant that an incident ray, hitting and transmitted, then lost would have bounds as the exit_device.\\n #self.exit_device = self.container\\n self.exit_device = intersection_object\\n self.previous_container = self.container\\n self.container = intersection_object\\n return self\",\n \"def obj_ray_cast(obj, matrix):\\r\\n \\r\\n # get the ray relative to the object\\r\\n matrix_inv = matrix.inverted()\\r\\n ray_origin_obj = matrix_inv * ray_origin\\r\\n ray_target_obj = matrix_inv * ray_target\\r\\n ray_direction_obj = ray_target_obj - ray_origin_obj\\r\\n \\r\\n # cast the ray\\r\\n success, location, normal, face_index = obj.ray_cast(ray_origin_obj, ray_direction_obj)\\r\\n \\r\\n if success:\\r\\n return location, normal, face_index\\r\\n else:\\r\\n return None, None, None\",\n \"def is_hit(ball, r_ball, v, target, r_target):\\n v_norm = norm_2d(v)\\n dr = (target[0] - ball[0], target[1] - ball[1])\\n dr_norm = norm_2d(dr)\\n\\n p = project(dr, v)\\n p_norm = norm_2d(p)\\n\\n if p_norm > v_norm:\\n c = (v_norm ** 2 + dr_norm ** 2 - 2 * sc_mul(v, dr)) ** 0.5\\n return c <= r_ball + r_target\\n\\n h = get_point_line_distance(target, ball, (-v[1], v[0]))\\n return abs(h) <= r_ball + r_target\",\n \"def obj_ray_cast(obj, matrix):\\n\\n # get the ray relative to the object\\n matrix_inv = matrix.inverted()\\n ray_origin_obj = matrix_inv * ray_origin\\n ray_target_obj = matrix_inv * ray_target\\n ray_direction_obj = ray_target_obj - ray_origin_obj\\n \\n # cast the ray\\n success, location, normal, face_index = obj.ray_cast(ray_origin_obj, ray_direction_obj)\\n\\n if success:\\n return location, normal, face_index, ray_target\\n else:\\n return None, None, None, ray_target\",\n \"def obj_ray_cast(obj, matrix):\\n\\n # get the ray relative to the object\\n matrix_inv = matrix.inverted()\\n ray_origin_obj = matrix_inv * ray_origin\\n ray_target_obj = matrix_inv * ray_target\\n ray_direction_obj = ray_target_obj - ray_origin_obj\\n\\n # cast the ray\\n success, location, normal, face_index = obj.ray_cast(ray_origin_obj, ray_direction_obj)\\n\\n if success:\\n return location, normal, face_index\\n else:\\n return None, None, None\",\n \"def closest_point_on_plane(point, plane):\\n base, normal = plane\\n x, y, z = base\\n a, b, c = normalize_vector(normal)\\n x1, y1, z1 = point\\n d = a * x + b * y + c * z\\n k = (a * x1 + b * y1 + c * z1 - d) / (a**2 + b**2 + c**2)\\n return [x1 - k * a,\\n y1 - k * b,\\n z1 - k * c]\",\n \"def on_road(self):\\n for obj in self.model.grid[self.pos[0]][self.pos[1]]:\\n if obj.agent_type == \\\"road\\\":\\n return obj\",\n \"def obj_ray_cast(obj, matrix):\\n\\n # get the ray relative to the object\\n matrix_inv = matrix.inverted()\\n ray_origin_obj = matrix_inv @ ray_origin\\n ray_target_obj = matrix_inv @ ray_target\\n ray_direction_obj = ray_target_obj - ray_origin_obj\\n\\n # cast the ray\\n success, location, normal, face_index = obj.ray_cast(ray_origin_obj, ray_direction_obj)\\n\\n if success:\\n return location, normal, face_index\\n else:\\n return None, None, None\",\n \"def follow(ray: Ray, scene: Scene, max_iters=1000, renderer=None) -> [Tuple[Ray, Decision]]:\\n path = [(ray, Decision.EMIT)]\\n idx = 0\\n last_ray = ray\\n while ray.is_alive:\\n intersections = scene.intersections(ray.position, ray.direction)\\n points, nodes = zip(*[(x.point, x.hit) for x in intersections])\\n for ray, decision in step(ray, points, nodes, renderer=renderer):\\n path.append((ray, decision))\\n if points_equal(ray.position, last_ray.position) and np.allclose(ray.direction, last_ray.direction):\\n raise TraceError(\\\"Ray did not move.\\\")\\n last_ray = ray\\n if idx > max_iters:\\n raise TraceError(\\\"Ray got stuck.\\\")\\n return path\",\n \"def HitTest(self, x, y):\\r\\n\\r\\n return 0\",\n \"def get_point(k, refpt):\\n i = 0\\n while i < k:\\n rho, theta = np.random.uniform(r, 2*r), np.random.uniform(0, 2*np.pi)\\n pt = refpt[0] + rho*np.cos(theta), refpt[1] + rho*np.sin(theta), 0\\n if not (0 <= pt[0] < width and 0 <= pt[1] < height):\\n # This point falls outside the domain of the grid, so try again.\\n i += 1\\n continue\\n if point_valid(pt) and is_on_face(pt, v1, v2, v3):\\n return pt\\n i += 1\\n # We failed to find a suitable point in the vicinity of refpt.\\n return False\",\n \"def hit(self, origin, sightVector, hitError):\\n distance = [0, 0, 0]\\n for i in range(0, 3):\\n distance[i] = self.translation[i] - origin[i]\\n v1 = normalize(distance)\\n v2 = normalize(sightVector)\\n return abs(v1[0] - v2[0]) < hitError and \\\\\\n abs(v1[1] - v2[1]) < hitError and abs(v1[2] - v2[2]) < hitError\",\n \"def hit(self, otherball):\\r\\n dx = (self.unif[0] + self.vx) - (otherball.unif[0] + otherball.vx)\\r\\n dy = (self.unif[1] + self.vy) - (otherball.unif[1] + otherball.vy)\\r\\n rd = self.radius + otherball.radius\\r\\n return dot(dx, dy) < (rd * rd)\",\n \"def step(ray, points, nodes, renderer=None):\\n container, to_node, surface_node = ray_status(ray, points, nodes)\\n min_point = ray.position\\n max_point = points[0]\\n \\n dist = distance_between(min_point, max_point)\\n _ray = ray\\n for (ray, decision) in trace_path(ray, container, dist):\\n if renderer:\\n renderer.add_ray_path([_ray, ray])\\n _ray = ray\\n yield ray, decision\\n\\n if to_node is None and container.parent is None:\\n # Case: Hit world node; kill ray here.\\n ray = replace(ray, is_alive=False)\\n yield ray, Decision.KILL\\n elif points_equal(ray.position, max_point):\\n # Case: Hit surface\\n # NB The ray argument of `trace_surface` *must* be a ray on the surface of the \\n # node and the returned ray must *not* be on the node!\\n before_ray = ray\\n _ray = ray\\n for ray, decision in trace_surface(ray, container, to_node, surface_node):\\n if renderer:\\n renderer.add_ray_path([_ray, ray])\\n _ray = ray\\n yield ray, decision\\n # Avoid error checks in production\\n if __debug__:\\n local_ray = ray.representation(surface_node.root, surface_node)\\n if surface_node.geometry.is_on_surface(local_ray.position):\\n logger.warning(\\\"(before) pos: {}\\\".format(before_ray.position))\\n logger.warning(\\\"(after) pos: {}\\\".format(ray.position))\\n raise TraceError(\\\"After tracing a surface the ray cannot still be on the surface.\\\")\",\n \"def point_sur_segment(self, pt):\\n dp = pt - self.c\\n d = dp.length - self.r\\n a = atan2(dp.y, dp.x)\\n t = (a - self.a0) / self.da\\n return t > 0 and t < 1, d, t\",\n \"def sample(self, z_position):\\n if self.direction[2] != 0:\\n z_plane = PlaneSurface([0, 0, 1], [0, 0, z_position])\\n if (z_plane.position() - self.position).dot(self.direction) > 0:\\n ray = self\\n else:\\n ray = Ray(-self.direction, self.position)\\n return ray.propagate(z_plane.time_to_bound(ray)).position\",\n \"def illuminate(self, ray, hit, scene):\\n # TODO A5 copy implementation from A4 and modify\\n # material parameters need to be looked up by the uv's at the intersection point\\n l = self.position - hit.point\\n epsilon = 0.000001\\n point = hit.point + l*epsilon\\n shadow_ray = Ray(point, l, epsilon, 1)\\n\\n if (scene.intersect(shadow_ray).t > 1):\\n\\n # diffuse shading\\n intensity = self.intensity\\n position = self.position\\n normal = hit.normal\\n dist_to_source = np.linalg.norm(hit.point - position)\\n diffuse_coeff = hit.material.lookup(hit.material.k_d, hit)\\n v = (-1) * normalize(ray.direction)\\n light_ray = normalize(position - hit.point)\\n specular_coeff = hit.material.lookup(hit.material.k_s, hit)\\n p = hit.material.lookup(hit.material.p, hit)\\n\\n # diffuse shading\\n # diffuse_output = diffuse_coeff * (np.maximum(0, np.dot(normal, light_ray)) / (dist_to_source ** 2)) * intensity\\n # specular shading\\n shade_ray = Ray(hit.point, light_ray, epsilon)\\n if (scene.intersect(shade_ray).t == np.inf):\\n h = (v + light_ray) / np.linalg.norm(v + light_ray)\\n specular_output = (diffuse_coeff + specular_coeff * ((np.dot(normal, h)) ** p)) * (\\n np.maximum(0, np.dot(normal, light_ray)) / (dist_to_source ** 2)) * intensity\\n return specular_output\\n\\n return vec([0, 0, 0])\",\n \"def hitDetect(self, direction, solid):\\n # Hit edge code not finished - A-Small-Being\\n modX = self.x\\n modY = self.y\\n if direction == Direction.LEFT:\\n modX -= 1\\n elif direction == Direction.RIGHT:\\n modX += 1\\n elif direction == Direction.UP:\\n modY -= 1\\n elif direction == Direction.DOWN:\\n modY += 1\\n\\n if (modX, modY) in solid:\\n return True\\n\\n if modX == 0:\\n #too far left\\n pass\\n elif modX == self.gameWindow.TILEWIDTH + 1:\\n # Too far right\\n pass\\n elif modY == 0:\\n # Too far up\\n pass\\n elif modY == self.gameWindow.TILEHEIGHT + 1:\\n # Too far down\\n pass\\n else:\\n # Fine\\n return False\\n return True\",\n \"def collision_detection(p, poly):\\r\\n _eps = 0.00001\\r\\n _huge = sys.float_info.max\\r\\n _tiny = sys.float_info.min\\r\\n \\r\\n def rayintersectseg(p, edge):\\r\\n ''' takes a point p=Pt() and an edge of two endpoints a,b=Pt() of a line segment returns boolean\\r\\n '''\\r\\n a,b = edge\\r\\n if a.y > b.y:\\r\\n a,b = b,a\\r\\n if p.y == a.y or p.y == b.y:\\r\\n p = Pt(p.x, p.y + _eps)\\r\\n \\r\\n intersect = False\\r\\n \\r\\n if (p.y > b.y or p.y < a.y) or (\\r\\n p.x > max(a.x, b.x)):\\r\\n return False\\r\\n \\r\\n if p.x < min(a.x, b.x):\\r\\n intersect = True\\r\\n else:\\r\\n if abs(a.x - b.x) > _tiny:\\r\\n m_red = (b.y - a.y) / float(b.x - a.x)\\r\\n else:\\r\\n m_red = _huge\\r\\n if abs(a.x - p.x) > _tiny:\\r\\n m_blue = (p.y - a.y) / float(p.x - a.x)\\r\\n else:\\r\\n m_blue = _huge\\r\\n intersect = m_blue >= m_red\\r\\n return intersect\\r\\n \\r\\n def _odd(x): return x%2 == 1\\r\\n \\r\\n def ispointinside(p, poly):\\r\\n\\r\\n return _odd(sum(rayintersectseg(p, edge)\\r\\n for edge in poly.edges ))\\r\\n \\r\\n detection = ispointinside(p,poly)\\r\\n return detection\",\n \"def ray_trace(x, y, poly):\\n\\n @vectorize([bool_(float64, float64)])\\n def ray(x, y):\\n # where xy is a coordinate\\n n = len(poly)\\n inside = False\\n p2x = 0.0\\n p2y = 0.0\\n xints = 0.0\\n p1x, p1y = poly[0]\\n for i in range(n + 1):\\n p2x, p2y = poly[i % n]\\n if y > min(p1y, p2y):\\n if y <= max(p1y, p2y):\\n if x <= max(p1x, p2x):\\n if p1y != p2y:\\n xints = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x\\n if p1x == p2x or x <= xints:\\n inside = not inside\\n p1x, p1y = p2x, p2y\\n return inside\\n\\n return ray(x, y)\",\n \"def _hitTest(self, point):\\n point = self.CalcUnscrolledPosition(point)\\n for displayKey in self._displayKeys.values():\\n if displayKey.scaled.Contains(point):\\n return displayKey\\n return None\",\n \"def closest_on_screen_point_optim(trajectory, viewpoint, yaw, gaze_on_screen):\\n \\n traj_angles = dp.world_to_angles_through_screen(trajectory, viewpoint, yaw) \\n \\n #pprint(traj_angles)\\n\\n dist, idx = closest_node_tree(traj_angles, gaze_on_screen)\\n ml_screen_ref = traj_angles[idx] \\n\\n return(idx, ml_screen_ref)\",\n \"def get_projection_point(self, point, plane, test=False):\\n return point_on_plane_projection(point, plane, test=test)\",\n \"def mesh_ray_collision(mesh: jnp.ndarray, origin: jnp.ndarray, direction: jnp.ndarray):\\n collides, positions, distances = jax.vmap(\\n lambda t: _triangle_ray_collision(t, origin, direction)\\n )(mesh)\\n idx = jnp.argmin(jnp.where(collides, distances, jnp.inf))\\n return (\\n jnp.any(collides),\\n positions[idx],\\n _triangle_normal(mesh[idx]),\\n )\",\n \"def get_object_at_location(cls, x, y):\\n object_map_at_target_location = cls.query\\\\\\n .filter_by(x=x, y=y).one_or_none()\\n if not object_map_at_target_location:\\n return None\\n return object_map_at_target_location.get_real_object()\",\n \"def line_intersection(p0_x, p0_y, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y):\\n s10_x = p1_x - p0_x\\n s10_y = p1_y - p0_y\\n s32_x = p3_x - p2_x\\n s32_y = p3_y - p2_y\\n\\n denom = s10_x * s32_y - s32_x * s10_y\\n if denom == 0.0:\\n return None # Collinear\\n denomPositive = denom > 0\\n\\n s02_x = p0_x - p2_x\\n s02_y = p0_y - p2_y\\n s_numer = s10_x * s02_y - s10_y * s02_x\\n if (s_numer < 0) == denomPositive:\\n return None # No collision\\n\\n t_numer = s32_x * s02_y - s32_y * s02_x\\n if (t_numer < 0) == denomPositive:\\n return None # No collision\\n\\n if (s_numer > denom) == denomPositive or (t_numer > denom) == denomPositive:\\n return 0 # No collision\\n \\n # Collision detected\\n t = t_numer / denom\\n i_x = p0_x + (t * s10_x)\\n i_y = p0_y + (t * s10_y)\\n\\n return i_x, i_y\",\n \"def findminpath(tab, gxtab, gytab, pixtab):\\n\\n pathdist = 2 # the number of points each points on a ray can related to on the previous ray\\n pathdist_penalty = 0.3 # penalty of the difference of the pathdist\\n pathpix_penalty = 2 # penalty of the difference of pixel values between the point and the previous point\\n nray = tab.shape[1]\\n\\n #tab = np.hstack((tab,tab[:, 0].reshape(tab.shape[0], 1)))\\n #pixtab = np.hstack((pixtab,pixtab[:, 0].reshape(pixtab.shape[0], 1)))\\n #gxtab = np.hstack((gxtab,gxtab[:, 0].reshape(gxtab.shape[0], 1)))\\n #gytab = np.hstack((gytab,gytab[:, 0].reshape(gytab.shape[0], 1)))\\n\\n tab = np.hstack((tab,tab,tab)) # horizontally stack the tab matrix to prepare for the filtering on the result\\n pixtab = np.hstack((pixtab,pixtab,pixtab))\\n gxtab = np.hstack((gxtab,gxtab,gxtab))\\n gytab = np.hstack((gytab,gytab,gytab))\\n\\n tab = (tab - tab.min()) / (tab.max() - tab.min()) # noralize the tab matrix\\n pixtab = (pixtab - pixtab.min()) / (pixtab.max() - pixtab.min()) * -1 # for we want to find the white contour of the cell so we multipy -1 on the pixtab\\n # tab = tab / np.median(tab)\\n # pixtab = pixtab / np.median(pixtab)\\n path = np.zeros(tab.shape)\\n path[:, 0] = np.array(range(0, tab.shape[0]))\\n score = np.zeros(tab.shape)\\n score[:, 1] = tab[:, 1]\\n\\n for i in range(1, tab.shape[1]):\\n for j in range(tab.shape[0]):\\n mins = np.Inf # record the min value of the ray\\n minat = 0\\n for k in range(-pathdist, pathdist+1):\\n if(0 <= (j+k) and (j+k) < tab.shape[0]):\\n s = pixtab[j, i]\\n pixdiff = abs(pixtab[j, i] - pixtab[j+k, i-1])\\n s += pixdiff * pathpix_penalty # two kinds of penalty\\n s += abs(k) * pathdist_penalty\\n s += score[j+k, i-1]\\n\\n if(s < mins):\\n mins = s\\n minat = j + k\\n path[j, i] = minat\\n score[j, i]= mins\\n\\n start = int(np.argmin(score[:, -1]))\\n path = path.astype(np.int32)\\n minpath = [start]\\n for i in range(tab.shape[1]-1, 0, -1):\\n minpath.append(path[minpath[-1], i])\\n minpath = minpath[::-1]\\n # print(len(minpath))\\n minpath = savgol_filter(minpath, 15, 3) # apply a Savitzky-Golay filter to the raw minpath signal\\n minpath = minpath[nray:nray*2] # cut the middle part of minpath whose length is nray\\n return np.array(minpath).astype(np.int32)\",\n \"def test_point_on_plane(self, point, plane):\\n _dist = point.dot(plane[:3]) + plane[3]\\n if _dist <= epsilon:\\n print('OK => point on plane')\\n else:\\n print('NO => point not on plane')\",\n \"def hit(self):\",\n \"def _pickFull(self, context):\\n rayObject = context.getPickingSegment(frame=self._getScenePrimitive())\\n if rayObject is None:\\n return None\\n\\n points = utils.segmentPlaneIntersect(\\n rayObject[0, :3],\\n rayObject[1, :3],\\n planeNorm=self.getNormal(),\\n planePt=self.getPoint())\\n\\n if len(points) == 1: # Single intersection\\n if numpy.any(points[0] < 0.):\\n return None # Outside volume\\n z, y, x = int(points[0][2]), int(points[0][1]), int(points[0][0])\\n\\n data = self.getData(copy=False)\\n if data is None:\\n return None # No dataset\\n\\n depth, height, width = data.shape\\n if z < depth and y < height and x < width:\\n return PickingResult(self,\\n positions=[points[0]],\\n indices=([z], [y], [x]))\\n else:\\n return None # Outside image\\n else: # Either no intersection or segment and image are coplanar\\n return None\",\n \"def get_hit_marker(self):\\r\\n return Marker((0, 0, 0), self._screen)\",\n \"def GetPlane(plane):\\r\\n pass\",\n \"def hit(self, other=None, push=False):\\n laser = pygame.mixer.Sound('resources/Laser.wav')\\n laser.set_volume(0.5)\\n if not other:\\n front_pos = \\\\\\n [p + d for p, d in zip(self.pos, DIRECTIONS[self.rotation])]\\n other = self.map.get(front_pos)\\n assert other is not None, \\\"No robot in front!\\\"\\n if push:\\n other.pos = [p + d for p, d in\\n zip(other.pos, DIRECTIONS[self.rotation])]\\n # get the hit direction\\n look_other = DIRECTIONS[other.rotation]\\n look_self = DIRECTIONS[self.rotation]\\n if look_other == look_self: # von hinten getroffen\\n damage = DAMAGE[FROM_BEHIND]\\n elif all(abs(x) != abs(y)\\n for x, y in zip(look_other, look_self)): # seitlich\\n damage = DAMAGE[FROM_SIDE]\\n else: # frontal\\n damage = DAMAGE[FROM_FRONT]\\n\\n other.health -= damage if not push else damage * 0.25\\n\\n if hasattr(other, 'take_damage_anim'):\\n other.animator.play_animation(other.take_damage_anim)\\n if self.speakers:\\n self.speakers.play(laser)\\n new_turn = \\\"{0}!{1};{2}\\\".format(self.pos, other.pos, damage)\\n self._call_gamelog_callbacks(new_turn)\",\n \"def hit(self, rect):\\n \\n # Find the hits at the current level\\n hits = set(item for item in self.items if rect.contains(item.location))\\n \\n # Recursively check the lower quadrants\\n if self.nw and rect.left < self.cx and rect.top < self.cy:\\n hits |= self.nw.hit(rect)\\n if self.sw and rect.left < self.cx and rect.bottom >= self.cy:\\n hits |= self.sw.hit(rect)\\n if self.ne and rect.right >= self.cx and rect.top < self.cy:\\n hits |= self.ne.hit(rect)\\n if self.se and rect.right >= self.cx and rect.bottom >= self.cy:\\n hits |= self.se.hit(rect)\\n \\n return hits\",\n \"def get_mouse_ray(self, context, event):\\n region, rv3d = context.region, context.region_data\\n coord = event.mouse_region_x, event.mouse_region_y\\n ray_direction = view3d_utils.region_2d_to_vector_3d(region, rv3d, coord)\\n ray_origin = view3d_utils.region_2d_to_origin_3d(region, rv3d, coord)\\n return ray_origin, ray_direction\",\n \"def intersection_segment_plane(segment, plane, epsilon=1e-6):\\n pt1 = segment[0]\\n pt2 = segment[1]\\n p_cent = plane[0]\\n p_norm = plane[1]\\n\\n v1 = subtract_vectors(pt2, pt1)\\n dot = dot_vectors(p_norm, v1)\\n\\n if abs(dot) > epsilon:\\n v2 = subtract_vectors(pt1, p_cent)\\n fac = -dot_vectors(p_norm, v2) / dot\\n if fac > 0. and fac < 1.:\\n vec = scale_vector(v1, fac)\\n return add_vectors(pt1, vec)\\n return None\\n else:\\n return None\",\n \"def goto_pt(self, pt):\\n curr_xy = [self.state.x, self.state.y]\\n target_xy = (pt[0], pt[1])\\n dist = math.sqrt((curr_xy[0] - target_xy[0])**2\\n + (curr_xy[1] - target_xy[1])**2)\\n\\n if dist > self.goto_thresh:\\n self.controller.target_velocity = self.goto_vel\\n steering, velocity = \\\\\\n self.controller.compute_control(self.state, target_xy)\\n self.data_handler.update_target(self.controller.target)\\n return steering, velocity\\n else:\\n self.controller.target_velocity = 0.0\\n steering = 0.0\\n velocity = 0.0\\n return steering, velocity\",\n \"def pred_car_other_lane(self):\\n other_lane = self.other_lane()\\n\\n for i in range(self.road.N):\\n if self.road.cells[other_lane][(self.x + i + 1) % (self.road.N-1)] != -1:\\n return self.road.cars[self.road.cells[other_lane][(self.x + i + 1) % (self.road.N-1)]]\",\n \"def linesegment_plane_intersection(self, p0,p1,point,normal): # only returns lines...intersections through the segment end points are ignored\\n\\t\\tp0dot=numpy.dot(p0-point,normal)\\n\\t\\tp1dot=numpy.dot(p1-point,normal)\\n\\t\\tif (p0dot>0 and p1dot<0) or (p0dot<0 and p1dot>0): \\n\\t\\t\\t# if the dot products have opposing signs, then the line intersects the plane\\n\\t\\t\\treturn True,p0+(p1-p0)*abs(p0dot)/(abs(p0dot)+abs(p1dot))\\n\\t\\telse:\\n\\t\\t\\treturn False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.724688","0.7169482","0.7158089","0.71482855","0.67915195","0.67516196","0.67201257","0.66962445","0.6689992","0.6683316","0.65686566","0.6530607","0.64233273","0.6218107","0.6107053","0.60904384","0.60822034","0.60539466","0.60471374","0.5973455","0.59581316","0.5944168","0.5883482","0.58700913","0.5852339","0.5827479","0.5778097","0.5777266","0.57022357","0.56945235","0.5648417","0.5611707","0.5563744","0.553851","0.5529523","0.55243814","0.5508424","0.5503527","0.5488689","0.5473283","0.5473044","0.54589635","0.5453586","0.54513234","0.54334146","0.54228675","0.5375146","0.5361326","0.5349615","0.53245085","0.5291477","0.5287521","0.52861947","0.5284544","0.52671903","0.526048","0.5222193","0.5215975","0.52079946","0.5206312","0.52010375","0.5195408","0.5185223","0.5182445","0.5162324","0.5141238","0.5134397","0.51294863","0.510286","0.5082481","0.5075469","0.5067873","0.50580376","0.5036729","0.50314003","0.5014529","0.5009622","0.49973068","0.49764273","0.4969208","0.49673837","0.49643046","0.49544537","0.49539417","0.49386123","0.49278378","0.49271864","0.49136552","0.49094453","0.48939368","0.4880124","0.48724905","0.4871798","0.48485523","0.4848538","0.4840595","0.4840551","0.48385227","0.48379028","0.4835317"],"string":"[\n \"0.724688\",\n \"0.7169482\",\n \"0.7158089\",\n \"0.71482855\",\n \"0.67915195\",\n \"0.67516196\",\n \"0.67201257\",\n \"0.66962445\",\n \"0.6689992\",\n \"0.6683316\",\n \"0.65686566\",\n \"0.6530607\",\n \"0.64233273\",\n \"0.6218107\",\n \"0.6107053\",\n \"0.60904384\",\n \"0.60822034\",\n \"0.60539466\",\n \"0.60471374\",\n \"0.5973455\",\n \"0.59581316\",\n \"0.5944168\",\n \"0.5883482\",\n \"0.58700913\",\n \"0.5852339\",\n \"0.5827479\",\n \"0.5778097\",\n \"0.5777266\",\n \"0.57022357\",\n \"0.56945235\",\n \"0.5648417\",\n \"0.5611707\",\n \"0.5563744\",\n \"0.553851\",\n \"0.5529523\",\n \"0.55243814\",\n \"0.5508424\",\n \"0.5503527\",\n \"0.5488689\",\n \"0.5473283\",\n \"0.5473044\",\n \"0.54589635\",\n \"0.5453586\",\n \"0.54513234\",\n \"0.54334146\",\n \"0.54228675\",\n \"0.5375146\",\n \"0.5361326\",\n \"0.5349615\",\n \"0.53245085\",\n \"0.5291477\",\n \"0.5287521\",\n \"0.52861947\",\n \"0.5284544\",\n \"0.52671903\",\n \"0.526048\",\n \"0.5222193\",\n \"0.5215975\",\n \"0.52079946\",\n \"0.5206312\",\n \"0.52010375\",\n \"0.5195408\",\n \"0.5185223\",\n \"0.5182445\",\n \"0.5162324\",\n \"0.5141238\",\n \"0.5134397\",\n \"0.51294863\",\n \"0.510286\",\n \"0.5082481\",\n \"0.5075469\",\n \"0.5067873\",\n \"0.50580376\",\n \"0.5036729\",\n \"0.50314003\",\n \"0.5014529\",\n \"0.5009622\",\n \"0.49973068\",\n \"0.49764273\",\n \"0.4969208\",\n \"0.49673837\",\n \"0.49643046\",\n \"0.49544537\",\n \"0.49539417\",\n \"0.49386123\",\n \"0.49278378\",\n \"0.49271864\",\n \"0.49136552\",\n \"0.49094453\",\n \"0.48939368\",\n \"0.4880124\",\n \"0.48724905\",\n \"0.4871798\",\n \"0.48485523\",\n \"0.4848538\",\n \"0.4840595\",\n \"0.4840551\",\n \"0.48385227\",\n \"0.48379028\",\n \"0.4835317\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7633641"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94977,"cells":{"query":{"kind":"string","value":"return the number of scalar components"},"document":{"kind":"string","value":"def getNumberOfScalarComponents(self):\n\t\treturn self.numberOfComponents"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def n_components(self):\n return 1","def n_components(self):\n return self._components.shape[0]","def n_cs(self):\n return np.size(self._cs, 0)","def components(self):\n return self.num_components","def __len__(self):\n num_x, num_y = self.conv_dims()\n return num_x * num_y","def GetNumberOfComponents():\n return _itkRGBAPixelPython.itkRGBAPixelF_GetNumberOfComponents()","def __len__(self):\n # Product function that can handle iterables (np.product can't).\n product = partial(reduce, operator.mul)\n modstr = '%s__' % self.modality\n return sum(product(len(v) for k, v in p.items() if modstr in k) if p else 1\n for p in self.param_grid)","def n_complex_components(self):\n return self.n_components // 2 + (self.n_components % 2)","def GetNumberOfComponents():\n return _itkRGBAPixelPython.itkRGBAPixelUS_GetNumberOfComponents()","def GetNumberOfComponents():\n return _itkRGBAPixelPython.itkRGBAPixelUC_GetNumberOfComponents()","def numel(self) -> int:\n return sum(p.numel() for p in self.parameters)","def numel(self):\n return self.t.size","def countComponents26(cube):\n n,l = labelComponents26(cube);\n return n;","def __len__(self):\n return np.size(self.A,0)","def n_cf(self):\n return np.size(self._ref_ii, 0)","def voxel_count(self):\n return self.cols * self.rows * self.sections","def __len__(self):\n # Product function that can handle iterables (np.product can't).\n product = partial(reduce, operator.mul)\n return sum(product(len(v) for v in p.values()) if p else 1\n for p in self.param_grid)","def count(self):\n return len(self._components)","def size(self)->int:\n\n return np.prod([axes if is_integer(axes) else len(axes) for axes in self._dim_axes])","def num_vars(self):\n return len(self.bounds.lb)","def itkRGBAPixelUS_GetNumberOfComponents():\n return _itkRGBAPixelPython.itkRGBAPixelUS_GetNumberOfComponents()","def itkRGBAPixelUC_GetNumberOfComponents():\n return _itkRGBAPixelPython.itkRGBAPixelUC_GetNumberOfComponents()","def itkRGBAPixelF_GetNumberOfComponents():\n return _itkRGBAPixelPython.itkRGBAPixelF_GetNumberOfComponents()","def __len__(self):\n n = 1\n for valTuple in self._valListOfLists:\n n *= len(valTuple)\n return n","def __len__(self):\n return len(self.components)","def __len__(self):\n return len(self.components)","def __len__(self):\n return len(self.kernels)","def __len__(self):\n\n try:\n return len(self.counts)\n except SpectrumError:\n return len(self.cps)","def n_elements(self) -> int:\n n_elem = np.prod(self.shape)\n if self.n_timesteps > 1:\n n_elem = int(n_elem / self.n_timesteps)\n return n_elem","def n_thres(self):\n return np.size(self.thres)","def _get_vector_size(self):\n if len(self):\n return len(self.values()[0])\n else:\n return 0","def ndim(self) -> int:\r\n return len(self.plates)","def nfactors(self):\n return self.L.nnz","def dim(self) -> int:","def nvar(self):\n return len(self.v)","def ndim(self):\n\n self._check_assigned()\n\n if (\n self.lazy\n and self.transformer is not None\n and hasattr(self.transformer, \"get_transformed_shape\")\n ):\n return len(self.transformer.get_transformed_shape(self.values))\n else:\n return self.__array__().ndim","def getNumElements(self):\n return 1","def _n_features_out(self):\n return self.components_.shape[0]","def len(self):\n return math.sqrt(self.v[0] * self.v[0] + self.v[1] * self.v[1])","def __len__(self):\n return len(self.__squares) * len(self.__squares[0])","def getDimension(self):\n return len(self.components)","def __len__(self):\n return self.xyz.shape[0]","def __len__(self):\n return self.xyz.shape[0]","def nvar(self):\n return self.h.shape[0]","def _N(self):\n return len(self._array)","def getNumElements(self):\n return 1","def size(self) -> int:\n return int(np.multiply(*self.shape))","def Num_Elem_Pila(self):\n return len(self.pila)","def num_elements(shape):\n return 1 if shape is None else int(np.prod(shape))","def nspatials(self):\n return int(len(self)/2)","def is_scalar(self):\n return len(self.coeffs.shape[self.sdim:]) == 0","def n_features(self):\n return self.components.shape[-1]","def number_of_basis(self):\n return self._pre_kernel.shape[0]","def size(self):\n return self._N","def ndim(self):\n return len(self.nvars)","def num_cuboids(self):\n return self._shape_count(_sff.cuboid)","def ndim(self):\n return len(self.point)","def __len__(self) -> int:\n return len(self.variables)","def length(self):\n return int(np.sum([x.length for x in self.parameters]))","def dimension(self):\r\n a = 0\r\n for x in self.faces():\r\n if (len(x) > a):\r\n a = len(x) \r\n return a-1","def get_number_of_components(df):\n n_components = 6 # since there a 6 numeric features\n pipe = _build_model(df, use_pca=True, n_components=n_components, use_kmeans=False, n_clusters=99)\n explained_variances = pipe.named_steps['pca'].explained_variance_ratio_\n plt.figure(7, figsize=(12, 6))\n plt.plot(range(1, 7), np.cumsum(explained_variances), 'o')\n plt.plot(range(1, 7), np.cumsum(explained_variances), '-', alpha=0.5)\n plt.xlabel('number of components')\n plt.ylabel('cumulative explained variance')\n plt.show()","def nt(self):\n if self.nClumps() > 0:\n \n return len(self[0])\n \n else:\n \n return 0","def getNumElements(self):\n return 0","def count_dims(da):\n return len(da.dims)","def nVariables(self):\n return len(self.variables)","def component_size(self) -> int:\n return self._component_size","def __len__(self):\n return self.N.shape[0]","def GetNumberOfVariables(self):\n\n # nvar = 0\n # for i in self.variables_order:\n # # DO NOT COUNT VARIABLES THAT GET CONDENSED OUT\n # if i!=0:\n # if mesh.element_type == \"tri\":\n # nvar += (i+1)*(i+2) // 2\n # elif mesh.element_type == \"tet\":\n # nvar += (i+1)*(i+2)*(i+3) // 6\n # elif mesh.element_type == \"quad\":\n # nvar += (i+1)**2\n # elif mesh.element_type == \"hex\":\n # nvar += (i+1)**3\n\n # nvar = sum(self.variables_order)\n if self.nvar == None:\n self.nvar = self.ndim\n return self.nvar","def size(self):\n return len(self.array_form)","def numpoints(self):\n return len(self.pars) + 1 # so dof is 1","def size(self):\n return self.N","def calculate_num_params(self):\n num_params = 0\n for p in self.parameters():\n num_params += p.data.view(-1).size(0)\n return num_params","def size(self):\n return int(misc.intprod(self.shape))","def nClumps(self):\n \n return len(self)","def size(self):\n return reduce(mul, self.shape, 1)","def _get_parameter_count(self):\n parameters_d = 5;\n size_h = self.model.size_h\n return (size_h - 1) + size_h * (\n (size_h - 1) + parameters_d + (self.model.size_aa - 1) + \n (self.model.size_ss - 1) + (self.model.size_cis - 1)\n )","def __len__(self):\n # type: () -> int\n return self.shape[0]","def __len__(self):\n return self._vector.degree()","def _numel(x):\n return tf.cast(tf.reduce_prod(x.shape), x.dtype)","def length(self):\n return len(self.x)","def num_parameters(self) -> int:\n return len(self.w) + prod(self.v.shape) - len(self.v)","def __len__(self) -> int:\n\n return self.shape.shape[1]","def specht(mu):\n return StandardTableaux(mu).cardinality().n()","def get_num_variables(self):\n return len(self.variables)","def width(self) -> int:\n return self._obj[self.x_dim].size","def num_nodes(self):\n return ((len(self.tensor_u)+1) * (len(self.tensor_v)+1) *\n (len(self.tensor_w)+1))","def getNumDimensions(self):\n return len(self.di.keys())","def __len__(self) -> int:\n return self.disp_size ** 2","def ndim(self):\n return self.initial_value.ndim","def ndims(x):\n return len(x.get_shape())","def __len__(self):\n return len(self._representation_vector)","def count(self):\r\n return self.data_array.size","def __len__(self):\n\n value_length = []\n for v in chain(self.values(), self.metainfo_values()):\n if isinstance(v, LabelData):\n value_length.append(v.label.shape[0])\n elif is_splitable_var(v):\n value_length.append(len(v))\n else:\n continue\n\n # NOTE: If length of values are not same or the current data sample\n # is empty, return length as 1\n if len(list(set(value_length))) != 1:\n return 1\n\n length = value_length[0]\n return length","def nNx(self):\n return self.nCx + 1","def __len__(self):\n return self._vertices.shape[0]","def ndim(self):\n return self.__value.ndim","def __len__(self):\n a = 1\n for size in self.sizes:\n a *= size\n return a","def size(self):\n\t\treturn self.dims","def count(self):\n \n return len(self.img_lst)","def dim(self):\n return len(self._n)"],"string":"[\n \"def n_components(self):\\n return 1\",\n \"def n_components(self):\\n return self._components.shape[0]\",\n \"def n_cs(self):\\n return np.size(self._cs, 0)\",\n \"def components(self):\\n return self.num_components\",\n \"def __len__(self):\\n num_x, num_y = self.conv_dims()\\n return num_x * num_y\",\n \"def GetNumberOfComponents():\\n return _itkRGBAPixelPython.itkRGBAPixelF_GetNumberOfComponents()\",\n \"def __len__(self):\\n # Product function that can handle iterables (np.product can't).\\n product = partial(reduce, operator.mul)\\n modstr = '%s__' % self.modality\\n return sum(product(len(v) for k, v in p.items() if modstr in k) if p else 1\\n for p in self.param_grid)\",\n \"def n_complex_components(self):\\n return self.n_components // 2 + (self.n_components % 2)\",\n \"def GetNumberOfComponents():\\n return _itkRGBAPixelPython.itkRGBAPixelUS_GetNumberOfComponents()\",\n \"def GetNumberOfComponents():\\n return _itkRGBAPixelPython.itkRGBAPixelUC_GetNumberOfComponents()\",\n \"def numel(self) -> int:\\n return sum(p.numel() for p in self.parameters)\",\n \"def numel(self):\\n return self.t.size\",\n \"def countComponents26(cube):\\n n,l = labelComponents26(cube);\\n return n;\",\n \"def __len__(self):\\n return np.size(self.A,0)\",\n \"def n_cf(self):\\n return np.size(self._ref_ii, 0)\",\n \"def voxel_count(self):\\n return self.cols * self.rows * self.sections\",\n \"def __len__(self):\\n # Product function that can handle iterables (np.product can't).\\n product = partial(reduce, operator.mul)\\n return sum(product(len(v) for v in p.values()) if p else 1\\n for p in self.param_grid)\",\n \"def count(self):\\n return len(self._components)\",\n \"def size(self)->int:\\n\\n return np.prod([axes if is_integer(axes) else len(axes) for axes in self._dim_axes])\",\n \"def num_vars(self):\\n return len(self.bounds.lb)\",\n \"def itkRGBAPixelUS_GetNumberOfComponents():\\n return _itkRGBAPixelPython.itkRGBAPixelUS_GetNumberOfComponents()\",\n \"def itkRGBAPixelUC_GetNumberOfComponents():\\n return _itkRGBAPixelPython.itkRGBAPixelUC_GetNumberOfComponents()\",\n \"def itkRGBAPixelF_GetNumberOfComponents():\\n return _itkRGBAPixelPython.itkRGBAPixelF_GetNumberOfComponents()\",\n \"def __len__(self):\\n n = 1\\n for valTuple in self._valListOfLists:\\n n *= len(valTuple)\\n return n\",\n \"def __len__(self):\\n return len(self.components)\",\n \"def __len__(self):\\n return len(self.components)\",\n \"def __len__(self):\\n return len(self.kernels)\",\n \"def __len__(self):\\n\\n try:\\n return len(self.counts)\\n except SpectrumError:\\n return len(self.cps)\",\n \"def n_elements(self) -> int:\\n n_elem = np.prod(self.shape)\\n if self.n_timesteps > 1:\\n n_elem = int(n_elem / self.n_timesteps)\\n return n_elem\",\n \"def n_thres(self):\\n return np.size(self.thres)\",\n \"def _get_vector_size(self):\\n if len(self):\\n return len(self.values()[0])\\n else:\\n return 0\",\n \"def ndim(self) -> int:\\r\\n return len(self.plates)\",\n \"def nfactors(self):\\n return self.L.nnz\",\n \"def dim(self) -> int:\",\n \"def nvar(self):\\n return len(self.v)\",\n \"def ndim(self):\\n\\n self._check_assigned()\\n\\n if (\\n self.lazy\\n and self.transformer is not None\\n and hasattr(self.transformer, \\\"get_transformed_shape\\\")\\n ):\\n return len(self.transformer.get_transformed_shape(self.values))\\n else:\\n return self.__array__().ndim\",\n \"def getNumElements(self):\\n return 1\",\n \"def _n_features_out(self):\\n return self.components_.shape[0]\",\n \"def len(self):\\n return math.sqrt(self.v[0] * self.v[0] + self.v[1] * self.v[1])\",\n \"def __len__(self):\\n return len(self.__squares) * len(self.__squares[0])\",\n \"def getDimension(self):\\n return len(self.components)\",\n \"def __len__(self):\\n return self.xyz.shape[0]\",\n \"def __len__(self):\\n return self.xyz.shape[0]\",\n \"def nvar(self):\\n return self.h.shape[0]\",\n \"def _N(self):\\n return len(self._array)\",\n \"def getNumElements(self):\\n return 1\",\n \"def size(self) -> int:\\n return int(np.multiply(*self.shape))\",\n \"def Num_Elem_Pila(self):\\n return len(self.pila)\",\n \"def num_elements(shape):\\n return 1 if shape is None else int(np.prod(shape))\",\n \"def nspatials(self):\\n return int(len(self)/2)\",\n \"def is_scalar(self):\\n return len(self.coeffs.shape[self.sdim:]) == 0\",\n \"def n_features(self):\\n return self.components.shape[-1]\",\n \"def number_of_basis(self):\\n return self._pre_kernel.shape[0]\",\n \"def size(self):\\n return self._N\",\n \"def ndim(self):\\n return len(self.nvars)\",\n \"def num_cuboids(self):\\n return self._shape_count(_sff.cuboid)\",\n \"def ndim(self):\\n return len(self.point)\",\n \"def __len__(self) -> int:\\n return len(self.variables)\",\n \"def length(self):\\n return int(np.sum([x.length for x in self.parameters]))\",\n \"def dimension(self):\\r\\n a = 0\\r\\n for x in self.faces():\\r\\n if (len(x) > a):\\r\\n a = len(x) \\r\\n return a-1\",\n \"def get_number_of_components(df):\\n n_components = 6 # since there a 6 numeric features\\n pipe = _build_model(df, use_pca=True, n_components=n_components, use_kmeans=False, n_clusters=99)\\n explained_variances = pipe.named_steps['pca'].explained_variance_ratio_\\n plt.figure(7, figsize=(12, 6))\\n plt.plot(range(1, 7), np.cumsum(explained_variances), 'o')\\n plt.plot(range(1, 7), np.cumsum(explained_variances), '-', alpha=0.5)\\n plt.xlabel('number of components')\\n plt.ylabel('cumulative explained variance')\\n plt.show()\",\n \"def nt(self):\\n if self.nClumps() > 0:\\n \\n return len(self[0])\\n \\n else:\\n \\n return 0\",\n \"def getNumElements(self):\\n return 0\",\n \"def count_dims(da):\\n return len(da.dims)\",\n \"def nVariables(self):\\n return len(self.variables)\",\n \"def component_size(self) -> int:\\n return self._component_size\",\n \"def __len__(self):\\n return self.N.shape[0]\",\n \"def GetNumberOfVariables(self):\\n\\n # nvar = 0\\n # for i in self.variables_order:\\n # # DO NOT COUNT VARIABLES THAT GET CONDENSED OUT\\n # if i!=0:\\n # if mesh.element_type == \\\"tri\\\":\\n # nvar += (i+1)*(i+2) // 2\\n # elif mesh.element_type == \\\"tet\\\":\\n # nvar += (i+1)*(i+2)*(i+3) // 6\\n # elif mesh.element_type == \\\"quad\\\":\\n # nvar += (i+1)**2\\n # elif mesh.element_type == \\\"hex\\\":\\n # nvar += (i+1)**3\\n\\n # nvar = sum(self.variables_order)\\n if self.nvar == None:\\n self.nvar = self.ndim\\n return self.nvar\",\n \"def size(self):\\n return len(self.array_form)\",\n \"def numpoints(self):\\n return len(self.pars) + 1 # so dof is 1\",\n \"def size(self):\\n return self.N\",\n \"def calculate_num_params(self):\\n num_params = 0\\n for p in self.parameters():\\n num_params += p.data.view(-1).size(0)\\n return num_params\",\n \"def size(self):\\n return int(misc.intprod(self.shape))\",\n \"def nClumps(self):\\n \\n return len(self)\",\n \"def size(self):\\n return reduce(mul, self.shape, 1)\",\n \"def _get_parameter_count(self):\\n parameters_d = 5;\\n size_h = self.model.size_h\\n return (size_h - 1) + size_h * (\\n (size_h - 1) + parameters_d + (self.model.size_aa - 1) + \\n (self.model.size_ss - 1) + (self.model.size_cis - 1)\\n )\",\n \"def __len__(self):\\n # type: () -> int\\n return self.shape[0]\",\n \"def __len__(self):\\n return self._vector.degree()\",\n \"def _numel(x):\\n return tf.cast(tf.reduce_prod(x.shape), x.dtype)\",\n \"def length(self):\\n return len(self.x)\",\n \"def num_parameters(self) -> int:\\n return len(self.w) + prod(self.v.shape) - len(self.v)\",\n \"def __len__(self) -> int:\\n\\n return self.shape.shape[1]\",\n \"def specht(mu):\\n return StandardTableaux(mu).cardinality().n()\",\n \"def get_num_variables(self):\\n return len(self.variables)\",\n \"def width(self) -> int:\\n return self._obj[self.x_dim].size\",\n \"def num_nodes(self):\\n return ((len(self.tensor_u)+1) * (len(self.tensor_v)+1) *\\n (len(self.tensor_w)+1))\",\n \"def getNumDimensions(self):\\n return len(self.di.keys())\",\n \"def __len__(self) -> int:\\n return self.disp_size ** 2\",\n \"def ndim(self):\\n return self.initial_value.ndim\",\n \"def ndims(x):\\n return len(x.get_shape())\",\n \"def __len__(self):\\n return len(self._representation_vector)\",\n \"def count(self):\\r\\n return self.data_array.size\",\n \"def __len__(self):\\n\\n value_length = []\\n for v in chain(self.values(), self.metainfo_values()):\\n if isinstance(v, LabelData):\\n value_length.append(v.label.shape[0])\\n elif is_splitable_var(v):\\n value_length.append(len(v))\\n else:\\n continue\\n\\n # NOTE: If length of values are not same or the current data sample\\n # is empty, return length as 1\\n if len(list(set(value_length))) != 1:\\n return 1\\n\\n length = value_length[0]\\n return length\",\n \"def nNx(self):\\n return self.nCx + 1\",\n \"def __len__(self):\\n return self._vertices.shape[0]\",\n \"def ndim(self):\\n return self.__value.ndim\",\n \"def __len__(self):\\n a = 1\\n for size in self.sizes:\\n a *= size\\n return a\",\n \"def size(self):\\n\\t\\treturn self.dims\",\n \"def count(self):\\n \\n return len(self.img_lst)\",\n \"def dim(self):\\n return len(self._n)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74888134","0.7376706","0.7100258","0.70853853","0.70716816","0.6938483","0.69184744","0.68926495","0.68802017","0.68690693","0.6788687","0.67648643","0.6762822","0.6739765","0.67380327","0.67363364","0.671714","0.6700786","0.66510797","0.6639145","0.66346884","0.66238576","0.66186726","0.6610711","0.6609566","0.6609566","0.66025543","0.65967375","0.6596694","0.65787077","0.6545257","0.6523638","0.6521125","0.65192986","0.65190476","0.6503485","0.650108","0.6496861","0.6484584","0.64841115","0.6470093","0.6465665","0.6465665","0.64639896","0.6460598","0.64572453","0.6453727","0.64311445","0.6423383","0.64188284","0.6392824","0.63914937","0.63841105","0.63783085","0.6370214","0.6368872","0.6364317","0.6360981","0.63577","0.63483214","0.63479656","0.63461","0.6344622","0.6333371","0.63309187","0.6324675","0.63163584","0.6308178","0.6305977","0.62927955","0.62901586","0.6288476","0.6282235","0.6279312","0.62754345","0.6270198","0.626587","0.6259863","0.62534106","0.625024","0.6245406","0.6244992","0.6237537","0.6234222","0.62241125","0.62240297","0.622308","0.6222","0.62177086","0.6217456","0.621111","0.62095934","0.6205513","0.6205438","0.62023634","0.61885196","0.61864626","0.6179317","0.6174346","0.61708283"],"string":"[\n \"0.74888134\",\n \"0.7376706\",\n \"0.7100258\",\n \"0.70853853\",\n \"0.70716816\",\n \"0.6938483\",\n \"0.69184744\",\n \"0.68926495\",\n \"0.68802017\",\n \"0.68690693\",\n \"0.6788687\",\n \"0.67648643\",\n \"0.6762822\",\n \"0.6739765\",\n \"0.67380327\",\n \"0.67363364\",\n \"0.671714\",\n \"0.6700786\",\n \"0.66510797\",\n \"0.6639145\",\n \"0.66346884\",\n \"0.66238576\",\n \"0.66186726\",\n \"0.6610711\",\n \"0.6609566\",\n \"0.6609566\",\n \"0.66025543\",\n \"0.65967375\",\n \"0.6596694\",\n \"0.65787077\",\n \"0.6545257\",\n \"0.6523638\",\n \"0.6521125\",\n \"0.65192986\",\n \"0.65190476\",\n \"0.6503485\",\n \"0.650108\",\n \"0.6496861\",\n \"0.6484584\",\n \"0.64841115\",\n \"0.6470093\",\n \"0.6465665\",\n \"0.6465665\",\n \"0.64639896\",\n \"0.6460598\",\n \"0.64572453\",\n \"0.6453727\",\n \"0.64311445\",\n \"0.6423383\",\n \"0.64188284\",\n \"0.6392824\",\n \"0.63914937\",\n \"0.63841105\",\n \"0.63783085\",\n \"0.6370214\",\n \"0.6368872\",\n \"0.6364317\",\n \"0.6360981\",\n \"0.63577\",\n \"0.63483214\",\n \"0.63479656\",\n \"0.63461\",\n \"0.6344622\",\n \"0.6333371\",\n \"0.63309187\",\n \"0.6324675\",\n \"0.63163584\",\n \"0.6308178\",\n \"0.6305977\",\n \"0.62927955\",\n \"0.62901586\",\n \"0.6288476\",\n \"0.6282235\",\n \"0.6279312\",\n \"0.62754345\",\n \"0.6270198\",\n \"0.626587\",\n \"0.6259863\",\n \"0.62534106\",\n \"0.625024\",\n \"0.6245406\",\n \"0.6244992\",\n \"0.6237537\",\n \"0.6234222\",\n \"0.62241125\",\n \"0.62240297\",\n \"0.622308\",\n \"0.6222\",\n \"0.62177086\",\n \"0.6217456\",\n \"0.621111\",\n \"0.62095934\",\n \"0.6205513\",\n \"0.6205438\",\n \"0.62023634\",\n \"0.61885196\",\n \"0.61864626\",\n \"0.6179317\",\n \"0.6174346\",\n \"0.61708283\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8905581"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94978,"cells":{"query":{"kind":"string","value":"Set the color transfer function"},"document":{"kind":"string","value":"def setColorTransferFunction(self, ctf):\n\t\tself.ctf = ctf"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def update_color(self):\r\n \r\n \r\n colorset = self.colorset\r\n \r\n self.grfx[0].colorset = colorset\r\n pass","def setColorDiffuse(*args):","def getColorTransferFunction(self):\n\t\treturn self.ctf","def set_color(self):\n self.image[self.x, self.y] = self.color\n if self.diffusion:\n r = g = b = 0\n for i in range(self.convolution_matrix.shape[0]):\n for j in range(self.convolution_matrix.shape[1]):\n r = g = b = 0\n for k in range(self.convolution_matrix.shape[0]):\n for l in range(self.convolution_matrix.shape[1]):\n m = (self.x + i + k - 2 + self.image.shape[0]) % self.image.shape[0]\n n = (self.y + j + l - 2 + self.image.shape[1]) % self.image.shape[1]\n r += self.convolution_matrix[k][l] * self.image[m, n][2]\n g += self.convolution_matrix[k][l] * self.image[m, n][1]\n b += self.convolution_matrix[k][l] * self.image[m, n][0]\n self.image[self.x, self.y] = (b, g, r)","def changeColor( self ):\n\t\t\n\t\tx, y = self.position.xy\n\t\tself.color = ( int((x / WINDOW_X) * 128), int((x / WINDOW_X) * 128) + int((y / WINDOW_Y) * 128 ), int((y / WINDOW_Y) * 128))","def changeColor(self):\n self.layer.new_colormap()","def set_color(self, color):\n\t\tpass","def set_color():\n function = LegacyFunctionSpecification()\n function.addParameter('index_of_the_particle', dtype='int32', direction=function.IN)\n for par in [\"red\", \"green\", \"blue\"]:\n function.addParameter(par, dtype='float64', direction=function.IN, \n description = \"The new RGB color vector of the particle\")\n function.addParameter('npoints', dtype='int32', direction=function.LENGTH)\n function.result_type = 'int32'\n function.must_handle_array = True\n return function","def getTweenColor(self, factor):\n\n pass","def UseColor(self, use_color):\n self.use_color = use_color","def set_color(self, color):\n pass","def set_color(color):\r\n global _current_color\r\n _current_color = color","def set_param(self, name, val):\n # name will be 'colorR', 'colorG', 'colorB'\n rgb255 = int(val * 255)\n if name == 'colorR':\n self.color.r = rgb255\n elif name == 'colorG':\n self.color.g = rgb255\n elif name == 'colorB':\n self.color.b = rgb255","def get_transfer_functioin(self, color_file=None, volume_opacity=0.25):\n if color_file: # Color file is given\n\n import csv\n fid = open(color_file, \"r\")\n reader_color = csv.reader(fid)\n\n dict_RGB = {}\n for line in reader_color:\n dict_RGB[int(line[0])] = [float(line[2]) / 255.0,\n float(line[3]) / 255.0,\n float(line[4]) / 255.0]\n fid.close()\n\n # Define colour transfer function\n color_transfor = vtk.vtkColorTransferFunction()\n\n for idx in dict_RGB.keys():\n color_transfor.AddRGBPoint(idx,\n dict_RGB[idx][0],\n dict_RGB[idx][1],\n dict_RGB[idx][2])\n\n # Opacity transfer function\n opacity_scalar = vtk.vtkPiecewiseFunction()\n\n for idx in dict_RGB.keys():\n opacity_scalar.AddPoint(\n idx, volume_opacity if idx != 0 else 0.0)\n\n # Opacity Gradient Transfer function\n opacity_gradient = vtk.vtkPiecewiseFunction()\n opacity_gradient.AddPoint(1, 0.0)\n opacity_gradient.AddPoint(5, 0.1)\n opacity_gradient.AddPoint(100, 1.0)\n\n return color_transfor, opacity_scalar, opacity_gradient\n\n else: # Default color transfer functions\n\n # min, max = self.get_value_range()\n color_transfor = vtk.vtkColorTransferFunction()\n color_transfor.AddRGBPoint(0, 0.0, 0.0, 0.0)\n color_transfor.AddRGBPoint(500, 1.0, 0.5, 0.3)\n color_transfor.AddRGBPoint(1000, 1.0, 0.5, 0.3)\n color_transfor.AddRGBPoint(1150, 1.0, 1.0, 0.9)\n\n # The opacity transfer function is used to control the opacity\n # of different tissue types.\n opacity_scalar = vtk.vtkPiecewiseFunction()\n opacity_scalar.AddPoint(0, 0.00)\n opacity_scalar.AddPoint(500, 0.15)\n opacity_scalar.AddPoint(1000, 0.15)\n opacity_scalar.AddPoint(1150, 0.85)\n\n # The gradient opacity function is used to decrease the opacity\n # in the \"flat\" regions of the volume while maintaining the opacity\n # at the boundaries between tissue types. The gradient is measured\n # as the amount by which the intensity changes over unit distance.\n # For most medical data, the unit distance is 1mm.\n opacity_gradient = vtk.vtkPiecewiseFunction()\n opacity_gradient.AddPoint(0, 0.0)\n opacity_gradient.AddPoint(90, 0.5)\n opacity_gradient.AddPoint(100, 1.0)\n\n return color_transfor, opacity_scalar, opacity_gradient","def set_color(self, new_color):\n self.color = new_color","def set_color(self, color):\n self.light_color = color\n for f in self.color_change_cb:\n f(self)","def refresh_color(self):\n self.color = max(0, int(math.sqrt(self.vx ** 2\n + self.vy ** 2)) + 100)","def _color(self, args):","def _update_color(self, color):\n self.color = color","def set_color(self, value):\n _lib.caca_set_dither_color.argtypes = [_Dither, ctypes.c_char_p]\n _lib.caca_set_dither_color.restype = ctypes.c_int\n\n return _lib.caca_set_dither_color(self, value)","def _update_color(self, *args):\n\n if self._variable and 'w' in self._mode and not self._dnd_started:\n self._internal_color_change = True\n self.color_var.set(self._variable)","def _color(self, x, factor):\r\n factor = (factor/MAX_LEVEL) * 1.8 + .1\r\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(x))\r\n x = tfa.image.blend(degenerate, tf.cast(x, tf.float32), factor)\r\n return tf.saturate_cast(x, tf.uint8)","def _set_hsvF(self, color):\n\n self.qcolor.setHsvF(color[0], color[1], color[2], 255)","def setColorMode(mode='full'):\n mdict = {'low':'NONE','full':'FULL'}\n dislin.clrmod(mdict[mode])","def test_color(self):\n self._calibration_test(\"color_full\")","def setPixelColor(self, n, color):\n self._logger.debug(\"setPixelColor\")","def change_color(self, color):\n self.color = color","def _set_color_mode(self, mode):\n self._write(ST7789_COLMOD, bytes([mode & 0x77]))","def __init__(self, *args, **kwargs):\n _gdi_.DCTextColourChanger_swiginit(self,_gdi_.new_DCTextColourChanger(*args, **kwargs))","def setColorRGB(r,g,b):\n r, g, b = r/255., g/255., b/255.\n dislin.setrgb(r,g,b)","def _set_color(self, r):\n c = COLORS[self.color]\n r.setLineColor(c[0], c[1], c[2])\n r.setColor(c[0], c[1], c[2])","def set_color_rgb(r, g, b):\r\n global _current_color\r\n _current_color = (r, g, b)","def color(self, color):\n #self._color = color\n new_color = \"{0}{1}{2}\".format(hex(int(color[0]))[2:].zfill(2),\n hex(int(color[1]))[2:].zfill(2),\n hex(int(color[2]))[2:].zfill(2))\n #self.log.info(\"RASPLes.color(%s : %s -> %s)\" % (self.number, color, new_color))\n #print(\"color(%s -> %s)\" % (self.number, new_color))\n try:\n self.current_color = new_color\n #self.strip.setPixelColor(int(self.number), self.current_color)\n self.strip.setPixelColorRGB(int(self.number), color[0], color[1], color[2])\n\n self.strip.updated = True\n except Exception as e:\n self.log.error(\"led update error\" + str(e))","def driftColor(baseColor, factor=110):\n if baseColor.lightness() > 128:\n return baseColor.darker(factor)\n else:\n return baseColor.lighter(factor+10)","def setColor(self):\n\n sel = cmds.ls(selection=True, type=['shape', 'transform'])\n if len(sel) > 0:\n for obj in sel:\n if cmds.nodeType(obj) == 'transform':\n shapes = cmds.listRelatives(obj, type='shape')\n if len(shapes) > 0 and self.shapeTypeCbx.isChecked():\n for shape in shapes:\n if cmds.attributeQuery('overrideEnabled', node=shape, exists=True):\n cmds.setAttr(shape + '.overrideEnabled', True)\n if self.colorsTab.currentIndex() == 0:\n if cmds.attributeQuery('overrideRGBColors', node=shape, exists=True):\n cmds.setAttr(shape + '.overrideRGBColors', False)\n if cmds.attributeQuery('overrideColor', node=shape, exists=True):\n cmds.setAttr(shape + '.overrideColor', self.colorSlider.value())\n else:\n if cmds.attributeQuery('overrideRGBColors', node=shape, exists=True):\n cmds.setAttr(shape + '.overrideRGBColors', True)\n if cmds.attributeQuery('overrideColorRGB', node=shape, exists=True):\n color = self.rgbColorDlg.currentColor()\n cmds.setAttr(shape + '.overrideColorRGB', color.red()/255.0, color.green()/255.0, color.blue()/255.0)\n\n if self.transformTypeCbx.isChecked():\n if cmds.attributeQuery('overrideEnabled', node=obj, exists=True):\n cmds.setAttr(obj + '.overrideEnabled', True)\n if self.colorsTab.currentIndex() == 0:\n if cmds.attributeQuery('overrideRGBColors', node=obj, exists=True):\n cmds.setAttr(obj + '.overrideRGBColors', False)\n if cmds.attributeQuery('overrideColor', node=obj, exists=True):\n cmds.setAttr(obj + '.overrideColor', self.colorSlider.value())\n else:\n if cmds.attributeQuery('overrideRGBColors', node=obj, exists=True):\n cmds.setAttr(obj + '.overrideRGBColors', True)\n if cmds.attributeQuery('overrideColorRGB', node=obj, exists=True):\n color = self.rgbColorDlg.currentColor()\n cmds.setAttr(obj + '.overrideColorRGB', color.red() / 255.0,\n color.green() / 255.0, color.blue() / 255.0)","def set_color(self, color):\n self.color = color","def assign_color(self,tank):\n tank.color = self.color_queue.popleft()","def Set(*args):\n return _XCAFDoc.XCAFDoc_ColorTool_Set(*args)","def fadeToRGB(self, color: tuple):\n r, g, b = color\n self._sendi2c('c', [r, g, b])","def Set(self, *args):\n return _itkRGBAPixelPython.itkRGBAPixelF_Set(self, *args)","def rgb(self, value):\n\n self._variable = value\n self._update()","def XCAFDoc_ColorTool_Set(*args):\n return _XCAFDoc.XCAFDoc_ColorTool_Set(*args)","def setColor(self,value):\n\t\tself.politics = value if(type(value) is int)else int(value[1:],16)\n\t\tself.canvas.itemconfig('node_'+self.identifier,fill=self.toRGB())","def setColourLevels(self):\n minsg = np.min(self.sg)\n maxsg = np.max(self.sg)\n brightness = self.brightnessSlider.value()\n contrast = self.contrastSlider.value()\n colourStart = (brightness / 100.0 * contrast / 100.0) * (maxsg - minsg) + minsg\n colourEnd = (maxsg - minsg) * (1.0 - contrast / 100.0) + colourStart\n for btn in self.picbuttons:\n btn.stopPlayback()\n btn.setImage(self.lut, colourStart, colourEnd, False)\n btn.update()","def set_color(self, r=0, g=0, b=0):\n r = clamp(r)\n g = clamp(g)\n b = clamp(b)\n self._state.color = (r, g, b)\n self.send_command(Command.SET_COLOR, [int(r), int(g), int(b)])","def setColorIndex(idx):\n dislin.setclr(idx)","def plot_color_changed(self):\n self.plot_color = self.plot_color_button.color()","def change_color(mutated_genome):\n index = random.randint(0,max(0,len(mutated_genome)-1))\n if color_mode == 'RGB':\n color_red = random.randint(-25,25)\n color_green = random.randint(-25,25)\n color_blue = random.randint(-25,25)\n color = mutated_genome[index][0]\n newcolor = (color[0]+color_red,color[1]+color_green,color[2]+color_blue)\n else: #color_mode == 'L':\n color_diff = random.randint(-25,25)\n color = mutated_genome[index][0]\n newcolor = color+color_diff\n mutated_genome[index][0] = newcolor","def slider_action(self, sender):\n self.r = self.rslider.value\n self.g = self.gslider.value\n self.b = self.bslider.value\n self.preview.background_color = self.rgb\n self.colorlabel.text = self.hexcode","def setColors(self):\n #productive\n profprint()\n self.color= [[0,0,0] for i in range(205)]\n self.color255= self.setColors255()\n for i in range(205):\n for j in range(3):\n self.color[i][j] = self.color255[i][j]/float(255)\n\n return self.color","def setColor(self, value):\n _res = self.mAPIContext.SDGraphObjectFrame_setColor(self.mHandle, ctypes.byref(value))\n if _res != SDApiError.NoError.value:\n if _res == SDApiError.NoErrorOutputParamNotSet.value:\n return None\n raise APIException(SDApiError(_res))\n return None","def color(self, value: tuple) -> None:\n if value in Color.PALETTE:\n self._color = value","def setColourMap(self):\n cmap = self.config['cmap']\n\n pos, colour, mode = colourMaps.colourMaps(cmap)\n\n cmap = pg.ColorMap(pos, colour,mode)\n self.lut = cmap.getLookupTable(0.0, 1.0, 256)\n minsg = np.min(self.sg)\n maxsg = np.max(self.sg)\n self.colourStart = (self.config['brightness'] / 100.0 * self.config['contrast'] / 100.0) * (maxsg - minsg) + minsg\n self.colourEnd = (maxsg - minsg) * (1.0 - self.config['contrast'] / 100.0) + self.colourStart","def set_red(x, y, value, slot = 0):\r\n __g[slot].pixels_rgb[__g[slot].width * 3 * y + x * 3] = value","def set_rgb(self, value):\n act = RGBAction(self, value)\n return act.invoke()","def rgb_slider_moved(self, event):\n slider_red = int(self.slider_r.get_value())\n slider_green = int(self.slider_g.get_value())\n slider_blue = int(self.slider_b.get_value())\n\n self.change_color((slider_red, slider_green, slider_blue))","def update_color(self):\n self.plot(update_traces=False, update_waveforms=True)","def color_callback(self, data):\n cv_image = self.bridge.imgmsg_to_cv2(data, desired_encoding=\"passthrough\")\n self.color_mutex.acquire()\n self.color_image = cv_image\n self.color_mutex.release()","def main():\n # color = rb.Color.BLUE.value\n # move_to_color(color)\n infared_sensor()\n\n # WHITE/RED does not work same with the BLUE/GREEN going down","def rgb_transition(self,r=0,g=0,b=0,duration=1,force=False):\n r=self.assert_int_255(r)\n g=self.assert_int_255(g)\n b=self.assert_int_255(b)\n #make this a no-op if we already are showing this color\n if not force and (r==self.r and g==self.g and b==self.b):\n return None\n \n tms = int(duration*1000)\n assert tms>=0 and tms<=0xffffffff\n t=tms.to_bytes(4,'little')\n\n logger.info(\n 'Transitioning device at %03d:%03d to RGB:%02x%02x%02x over %d ms',\n self.usbdev.bus,self.usbdev.address,r,g,b,tms)\n ret=self.usbdev.ctrl_transfer(bmRequestType=0x21, bRequest=0x09, wValue=0x03a2, wIndex=0, data_or_wLength=[0xa2,0x00,r,g,b,t[0],t[1],t[2],t[3]])\n self.r=r\n self.g=g\n self.b=b\n return ret","def collimator(self):\n self.spectrum = self.spectrum","def setColor(self, color):\n self.__color = color","def setChan(\n self,\n u,\n chan,\n fval,\n ):\n\n self.DMX[u].set_chan_float(chan, fval)","def setColourMap(self):\n cmap = self.config['cmap']\n\n pos, colour, mode = colourMaps.colourMaps(cmap)\n\n cmap = pg.ColorMap(pos, colour, mode)\n self.lut = cmap.getLookupTable(0.0, 1.0, 256)\n minsg = np.min(self.sg)\n maxsg = np.max(self.sg)\n self.colourStart = (self.config['brightness'] / 100.0 * self.config['contrast'] / 100.0) * (\n maxsg - minsg) + minsg\n self.colourEnd = (maxsg - minsg) * (1.0 - self.config['contrast'] / 100.0) + self.colourStart","def setColor(clr):\n if type(clr) == types.StringType:\n setColorString(clr)\n return \n if type(clr) == types.IntType:\n setColorIndex(clr)\n return\n if type(clr) == types.TupleType:\n setColorRGB(*clr)","def map_channels(self, map_function):\n return ScreenColor(map_function(self.red), map_function(self.green), map_function(self.blue))","def change_color():\n return random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)","def setSurfaceColorScale(low,high):\n dislin.zscale(low,high)","def set_color(objname, rgb):\r\n return f'\\ncmd.set_color(\"{objname}\", {(rgb[0], rgb[1], rgb[2])})'","def scale_to_01(color: C3I) -> C3F:\n r, g, b = color\n return r / 255, g / 255, b / 255","def gradfactor(self, f):\r\n raise NotImplementedError","def Set(*args, **kwargs):\n return _gdi_.Colour_Set(*args, **kwargs)","def update_r(color, new_r):\n\n color.update_r(new_r)","def SetRed(self, *args):\n return _itkRGBAPixelPython.itkRGBAPixelUS_SetRed(self, *args)","def set_color_mode(self, mode):\n mode=self._color_modes.get(mode,mode)\n res=lib.is_SetColorMode(self.hcam,mode)\n errcheck()(res,lib.is_SetColorMode,None)\n return self.get_color_mode()","def late_gradient_fusion():\n pass","def set_color(self):\n new_color = QColorDialog.getColor(QColor(self.config['color']))\n if not new_color.isValid():\n return\n self.config['color'] = new_color.rgb()\n self.paint()","def setColour(self, col):\n\t\tself.colour = col","def set_color(self, color):\n self._color = color","def set_palette(self, red, green, blue, alpha):\n raise DitherError(\"Not implemented\")","def change_lights_color(self, entity, attribute, oldUrl, newUrl, kwargs):\n if newUrl != oldUrl and newUrl is not None and self.can_change_colors():\n rgb_colors = self.get_colors(self.format_ha_url(newUrl))\n for i in range(len(self.lights)):\n threading.Thread(target=self.set_light_rgb, args=(self.lights[i], rgb_colors[i])).start()","def set_red_light(self, value):\n self.diffuse_light[0] = value\n self.redraw()","def setRandomColor():\n setColor(getRandomColor())","def set_contrast(value):\n command([0x21, 0x14, value, 0x20, 0x0c])","def brighter_switch(turtle, color):\n turtle.fillcolor(color + \"1\")","def on_rgb_slide(self,r,g,b):\n if not self.active:\n return\n red = int(round(r / 100.0))\n green = int(round(g / 100.0))\n blue = int(round(b / 100.0))\n self.rgb = colormodel.RGB(red, green, blue)\n self.hsv = a3.rgb_to_hsv(self.rgb)\n assert (self.hsv == None or type(self.hsv) == colormodel.HSV), 'rgb_to_hsv does not return a HSV object'\n self.cmyk = a3.rgb_to_cmyk(self.rgb)\n assert (self.cmyk == None or type(self.cmyk) == colormodel.CMYK), 'rgb_to_cmyk does not return a CMYK object'\n self.update()","def _color_change_mode(self):\r\n self.dlg.exec_()\r\n self.color = self.dlg.currentColor().name()\r\n self.colorPlate.setStyleSheet(\"background-color: %s;\" % self.color)\r\n self.input_scene.get_stk_color(self.color)\r\n return","def color_transfert():\n\n\n\tn_target = input(\"Tell me which picture wants a new make up.\\n\\n\")\n\tn_source = input(\"And now tell me which one she wanna look like \\n\\n\")\n\n\ttarget = cv.imread(n_target, 1)\n\tsource = cv.imread(n_source, 1)\n\n\t### So basically, target will get new colors from source\n\n\t## First let's convert them into the l alpha beta color space\n\n\tt_alpha = rgb2alpha(target)\n\ts_alpha = rgb2alpha(source)\n\n\n\t## Now let's make up our target thanks to some statistical operations\n\n\tm_target = make_up(t_alpha, s_alpha)\n\n\n\t## Finally we gonna convert target back to rgb space\n\n\tm_target = alpha2rgb(m_target)\n\n\t## And save it, so let's name it, you don't have to give the format, we'll add it here\n\n\tname = input(\"What's the name of the new picture ? \\n\")\n\n\tname += \".png\"\n\n\tcv.imwrite(name, m_target)\t\t# You can now post your new picture to instagramm and let\n\t\t\t\t\t\t# your followers believe that you are a skilled photograph.\t\n\t\t\t\t\t\t# I personally don't use this shit so fuck it.\n\n\tprint(\"{} saved.\".format(name))","def set_color(color='black', index=-1): # (8)\n if index == -1:\n global color_buffer\n color_buffer = deque([color]*NUM_LEDS, maxlen=NUM_LEDS)\n else:\n color_buffer[index] = color","def setPixelColorRGB(self, n, red, green, blue, white=0):\n self._logger.debug(\"setPixelColorRGB\")","def set_led_color(color):\n requests.post('http://192.168.4.1/pixel', data=json.dumps(color))","def fl_color(colr):\n _fl_color = library.cfuncproto(\n library.load_so_libforms(), \"fl_color\",\\\n None, [xfdata.FL_COLOR],\\\n \"\"\"void fl_color(FL_COLOR col)\"\"\")\n library.check_if_flinitialized()\n #library.checknonfatal_allowed_value_in_list(colr, xfdata.COLOR_list)\n ul_colr = library.convert_to_FL_COLOR(colr)\n library.keep_elem_refs(colr, ul_colr)\n _fl_color(ul_colr)","def change( p ):\n red = p[0]\n green = p[1]\n blue = p[2]\n return [ 255-red, 255-green, 255-blue ]","def log_forward_color(self, forward_func, *args, color=None, **kwargs):\n\t\tif color is None:\n\t\t\treturn forward_func(*args, **kwargs)\n\t\telse:\n\t\t\tif \"extra\" not in kwargs:\n\t\t\t\treturn forward_func(*args, extra=dict(color=color), **kwargs)\n\t\t\telse:\n\t\t\t\treturn forward_func(*args, **{**kwargs, \"extra\": {**kwargs[\"extra\"], \"color\": color}})","def switch(self, _color = 16):\n\t\tself.pointer.flip()\n\n\t\tif self.pointer.get():\n\t\t\tself.content[0][1] = 3\n\t\t\tself.content[1][1] = 16\n\t\telse:\n\t\t\tself.content[0][1] = 16\n\t\t\tself.content[1][1] = 3","def __init__(self, target_colour: Tuple[int, int, int]) -> None:\r\n self.colour = target_colour","def __init__(self, target_colour: Tuple[int, int, int]) -> None:\r\n self.colour = target_colour","def __init__(self, target_colour: Tuple[int, int, int]) -> None:\r\n self.colour = target_colour","def color(self, color):\n\n self.container['color'] = color","def on_autocolor_switch(self, action, value):\n\t\taction.set_state(value)\n\t\tautocolor = value.get_boolean()\n\t\tself.config[\"color\"][\"auto\"] = autocolor\n\n\t\tcolor = self.config[\"color\"][\"autofg\"] if autocolor else self.config[\"color\"][\"fg\"]\n\t\tself.gui[\"fg-colorbutton\"].set_rgba(color)\n\t\tself._mainapp.draw.color_update()"],"string":"[\n \"def update_color(self):\\r\\n \\r\\n \\r\\n colorset = self.colorset\\r\\n \\r\\n self.grfx[0].colorset = colorset\\r\\n pass\",\n \"def setColorDiffuse(*args):\",\n \"def getColorTransferFunction(self):\\n\\t\\treturn self.ctf\",\n \"def set_color(self):\\n self.image[self.x, self.y] = self.color\\n if self.diffusion:\\n r = g = b = 0\\n for i in range(self.convolution_matrix.shape[0]):\\n for j in range(self.convolution_matrix.shape[1]):\\n r = g = b = 0\\n for k in range(self.convolution_matrix.shape[0]):\\n for l in range(self.convolution_matrix.shape[1]):\\n m = (self.x + i + k - 2 + self.image.shape[0]) % self.image.shape[0]\\n n = (self.y + j + l - 2 + self.image.shape[1]) % self.image.shape[1]\\n r += self.convolution_matrix[k][l] * self.image[m, n][2]\\n g += self.convolution_matrix[k][l] * self.image[m, n][1]\\n b += self.convolution_matrix[k][l] * self.image[m, n][0]\\n self.image[self.x, self.y] = (b, g, r)\",\n \"def changeColor( self ):\\n\\t\\t\\n\\t\\tx, y = self.position.xy\\n\\t\\tself.color = ( int((x / WINDOW_X) * 128), int((x / WINDOW_X) * 128) + int((y / WINDOW_Y) * 128 ), int((y / WINDOW_Y) * 128))\",\n \"def changeColor(self):\\n self.layer.new_colormap()\",\n \"def set_color(self, color):\\n\\t\\tpass\",\n \"def set_color():\\n function = LegacyFunctionSpecification()\\n function.addParameter('index_of_the_particle', dtype='int32', direction=function.IN)\\n for par in [\\\"red\\\", \\\"green\\\", \\\"blue\\\"]:\\n function.addParameter(par, dtype='float64', direction=function.IN, \\n description = \\\"The new RGB color vector of the particle\\\")\\n function.addParameter('npoints', dtype='int32', direction=function.LENGTH)\\n function.result_type = 'int32'\\n function.must_handle_array = True\\n return function\",\n \"def getTweenColor(self, factor):\\n\\n pass\",\n \"def UseColor(self, use_color):\\n self.use_color = use_color\",\n \"def set_color(self, color):\\n pass\",\n \"def set_color(color):\\r\\n global _current_color\\r\\n _current_color = color\",\n \"def set_param(self, name, val):\\n # name will be 'colorR', 'colorG', 'colorB'\\n rgb255 = int(val * 255)\\n if name == 'colorR':\\n self.color.r = rgb255\\n elif name == 'colorG':\\n self.color.g = rgb255\\n elif name == 'colorB':\\n self.color.b = rgb255\",\n \"def get_transfer_functioin(self, color_file=None, volume_opacity=0.25):\\n if color_file: # Color file is given\\n\\n import csv\\n fid = open(color_file, \\\"r\\\")\\n reader_color = csv.reader(fid)\\n\\n dict_RGB = {}\\n for line in reader_color:\\n dict_RGB[int(line[0])] = [float(line[2]) / 255.0,\\n float(line[3]) / 255.0,\\n float(line[4]) / 255.0]\\n fid.close()\\n\\n # Define colour transfer function\\n color_transfor = vtk.vtkColorTransferFunction()\\n\\n for idx in dict_RGB.keys():\\n color_transfor.AddRGBPoint(idx,\\n dict_RGB[idx][0],\\n dict_RGB[idx][1],\\n dict_RGB[idx][2])\\n\\n # Opacity transfer function\\n opacity_scalar = vtk.vtkPiecewiseFunction()\\n\\n for idx in dict_RGB.keys():\\n opacity_scalar.AddPoint(\\n idx, volume_opacity if idx != 0 else 0.0)\\n\\n # Opacity Gradient Transfer function\\n opacity_gradient = vtk.vtkPiecewiseFunction()\\n opacity_gradient.AddPoint(1, 0.0)\\n opacity_gradient.AddPoint(5, 0.1)\\n opacity_gradient.AddPoint(100, 1.0)\\n\\n return color_transfor, opacity_scalar, opacity_gradient\\n\\n else: # Default color transfer functions\\n\\n # min, max = self.get_value_range()\\n color_transfor = vtk.vtkColorTransferFunction()\\n color_transfor.AddRGBPoint(0, 0.0, 0.0, 0.0)\\n color_transfor.AddRGBPoint(500, 1.0, 0.5, 0.3)\\n color_transfor.AddRGBPoint(1000, 1.0, 0.5, 0.3)\\n color_transfor.AddRGBPoint(1150, 1.0, 1.0, 0.9)\\n\\n # The opacity transfer function is used to control the opacity\\n # of different tissue types.\\n opacity_scalar = vtk.vtkPiecewiseFunction()\\n opacity_scalar.AddPoint(0, 0.00)\\n opacity_scalar.AddPoint(500, 0.15)\\n opacity_scalar.AddPoint(1000, 0.15)\\n opacity_scalar.AddPoint(1150, 0.85)\\n\\n # The gradient opacity function is used to decrease the opacity\\n # in the \\\"flat\\\" regions of the volume while maintaining the opacity\\n # at the boundaries between tissue types. The gradient is measured\\n # as the amount by which the intensity changes over unit distance.\\n # For most medical data, the unit distance is 1mm.\\n opacity_gradient = vtk.vtkPiecewiseFunction()\\n opacity_gradient.AddPoint(0, 0.0)\\n opacity_gradient.AddPoint(90, 0.5)\\n opacity_gradient.AddPoint(100, 1.0)\\n\\n return color_transfor, opacity_scalar, opacity_gradient\",\n \"def set_color(self, new_color):\\n self.color = new_color\",\n \"def set_color(self, color):\\n self.light_color = color\\n for f in self.color_change_cb:\\n f(self)\",\n \"def refresh_color(self):\\n self.color = max(0, int(math.sqrt(self.vx ** 2\\n + self.vy ** 2)) + 100)\",\n \"def _color(self, args):\",\n \"def _update_color(self, color):\\n self.color = color\",\n \"def set_color(self, value):\\n _lib.caca_set_dither_color.argtypes = [_Dither, ctypes.c_char_p]\\n _lib.caca_set_dither_color.restype = ctypes.c_int\\n\\n return _lib.caca_set_dither_color(self, value)\",\n \"def _update_color(self, *args):\\n\\n if self._variable and 'w' in self._mode and not self._dnd_started:\\n self._internal_color_change = True\\n self.color_var.set(self._variable)\",\n \"def _color(self, x, factor):\\r\\n factor = (factor/MAX_LEVEL) * 1.8 + .1\\r\\n degenerate = tf.image.grayscale_to_rgb(tf.image.rgb_to_grayscale(x))\\r\\n x = tfa.image.blend(degenerate, tf.cast(x, tf.float32), factor)\\r\\n return tf.saturate_cast(x, tf.uint8)\",\n \"def _set_hsvF(self, color):\\n\\n self.qcolor.setHsvF(color[0], color[1], color[2], 255)\",\n \"def setColorMode(mode='full'):\\n mdict = {'low':'NONE','full':'FULL'}\\n dislin.clrmod(mdict[mode])\",\n \"def test_color(self):\\n self._calibration_test(\\\"color_full\\\")\",\n \"def setPixelColor(self, n, color):\\n self._logger.debug(\\\"setPixelColor\\\")\",\n \"def change_color(self, color):\\n self.color = color\",\n \"def _set_color_mode(self, mode):\\n self._write(ST7789_COLMOD, bytes([mode & 0x77]))\",\n \"def __init__(self, *args, **kwargs):\\n _gdi_.DCTextColourChanger_swiginit(self,_gdi_.new_DCTextColourChanger(*args, **kwargs))\",\n \"def setColorRGB(r,g,b):\\n r, g, b = r/255., g/255., b/255.\\n dislin.setrgb(r,g,b)\",\n \"def _set_color(self, r):\\n c = COLORS[self.color]\\n r.setLineColor(c[0], c[1], c[2])\\n r.setColor(c[0], c[1], c[2])\",\n \"def set_color_rgb(r, g, b):\\r\\n global _current_color\\r\\n _current_color = (r, g, b)\",\n \"def color(self, color):\\n #self._color = color\\n new_color = \\\"{0}{1}{2}\\\".format(hex(int(color[0]))[2:].zfill(2),\\n hex(int(color[1]))[2:].zfill(2),\\n hex(int(color[2]))[2:].zfill(2))\\n #self.log.info(\\\"RASPLes.color(%s : %s -> %s)\\\" % (self.number, color, new_color))\\n #print(\\\"color(%s -> %s)\\\" % (self.number, new_color))\\n try:\\n self.current_color = new_color\\n #self.strip.setPixelColor(int(self.number), self.current_color)\\n self.strip.setPixelColorRGB(int(self.number), color[0], color[1], color[2])\\n\\n self.strip.updated = True\\n except Exception as e:\\n self.log.error(\\\"led update error\\\" + str(e))\",\n \"def driftColor(baseColor, factor=110):\\n if baseColor.lightness() > 128:\\n return baseColor.darker(factor)\\n else:\\n return baseColor.lighter(factor+10)\",\n \"def setColor(self):\\n\\n sel = cmds.ls(selection=True, type=['shape', 'transform'])\\n if len(sel) > 0:\\n for obj in sel:\\n if cmds.nodeType(obj) == 'transform':\\n shapes = cmds.listRelatives(obj, type='shape')\\n if len(shapes) > 0 and self.shapeTypeCbx.isChecked():\\n for shape in shapes:\\n if cmds.attributeQuery('overrideEnabled', node=shape, exists=True):\\n cmds.setAttr(shape + '.overrideEnabled', True)\\n if self.colorsTab.currentIndex() == 0:\\n if cmds.attributeQuery('overrideRGBColors', node=shape, exists=True):\\n cmds.setAttr(shape + '.overrideRGBColors', False)\\n if cmds.attributeQuery('overrideColor', node=shape, exists=True):\\n cmds.setAttr(shape + '.overrideColor', self.colorSlider.value())\\n else:\\n if cmds.attributeQuery('overrideRGBColors', node=shape, exists=True):\\n cmds.setAttr(shape + '.overrideRGBColors', True)\\n if cmds.attributeQuery('overrideColorRGB', node=shape, exists=True):\\n color = self.rgbColorDlg.currentColor()\\n cmds.setAttr(shape + '.overrideColorRGB', color.red()/255.0, color.green()/255.0, color.blue()/255.0)\\n\\n if self.transformTypeCbx.isChecked():\\n if cmds.attributeQuery('overrideEnabled', node=obj, exists=True):\\n cmds.setAttr(obj + '.overrideEnabled', True)\\n if self.colorsTab.currentIndex() == 0:\\n if cmds.attributeQuery('overrideRGBColors', node=obj, exists=True):\\n cmds.setAttr(obj + '.overrideRGBColors', False)\\n if cmds.attributeQuery('overrideColor', node=obj, exists=True):\\n cmds.setAttr(obj + '.overrideColor', self.colorSlider.value())\\n else:\\n if cmds.attributeQuery('overrideRGBColors', node=obj, exists=True):\\n cmds.setAttr(obj + '.overrideRGBColors', True)\\n if cmds.attributeQuery('overrideColorRGB', node=obj, exists=True):\\n color = self.rgbColorDlg.currentColor()\\n cmds.setAttr(obj + '.overrideColorRGB', color.red() / 255.0,\\n color.green() / 255.0, color.blue() / 255.0)\",\n \"def set_color(self, color):\\n self.color = color\",\n \"def assign_color(self,tank):\\n tank.color = self.color_queue.popleft()\",\n \"def Set(*args):\\n return _XCAFDoc.XCAFDoc_ColorTool_Set(*args)\",\n \"def fadeToRGB(self, color: tuple):\\n r, g, b = color\\n self._sendi2c('c', [r, g, b])\",\n \"def Set(self, *args):\\n return _itkRGBAPixelPython.itkRGBAPixelF_Set(self, *args)\",\n \"def rgb(self, value):\\n\\n self._variable = value\\n self._update()\",\n \"def XCAFDoc_ColorTool_Set(*args):\\n return _XCAFDoc.XCAFDoc_ColorTool_Set(*args)\",\n \"def setColor(self,value):\\n\\t\\tself.politics = value if(type(value) is int)else int(value[1:],16)\\n\\t\\tself.canvas.itemconfig('node_'+self.identifier,fill=self.toRGB())\",\n \"def setColourLevels(self):\\n minsg = np.min(self.sg)\\n maxsg = np.max(self.sg)\\n brightness = self.brightnessSlider.value()\\n contrast = self.contrastSlider.value()\\n colourStart = (brightness / 100.0 * contrast / 100.0) * (maxsg - minsg) + minsg\\n colourEnd = (maxsg - minsg) * (1.0 - contrast / 100.0) + colourStart\\n for btn in self.picbuttons:\\n btn.stopPlayback()\\n btn.setImage(self.lut, colourStart, colourEnd, False)\\n btn.update()\",\n \"def set_color(self, r=0, g=0, b=0):\\n r = clamp(r)\\n g = clamp(g)\\n b = clamp(b)\\n self._state.color = (r, g, b)\\n self.send_command(Command.SET_COLOR, [int(r), int(g), int(b)])\",\n \"def setColorIndex(idx):\\n dislin.setclr(idx)\",\n \"def plot_color_changed(self):\\n self.plot_color = self.plot_color_button.color()\",\n \"def change_color(mutated_genome):\\n index = random.randint(0,max(0,len(mutated_genome)-1))\\n if color_mode == 'RGB':\\n color_red = random.randint(-25,25)\\n color_green = random.randint(-25,25)\\n color_blue = random.randint(-25,25)\\n color = mutated_genome[index][0]\\n newcolor = (color[0]+color_red,color[1]+color_green,color[2]+color_blue)\\n else: #color_mode == 'L':\\n color_diff = random.randint(-25,25)\\n color = mutated_genome[index][0]\\n newcolor = color+color_diff\\n mutated_genome[index][0] = newcolor\",\n \"def slider_action(self, sender):\\n self.r = self.rslider.value\\n self.g = self.gslider.value\\n self.b = self.bslider.value\\n self.preview.background_color = self.rgb\\n self.colorlabel.text = self.hexcode\",\n \"def setColors(self):\\n #productive\\n profprint()\\n self.color= [[0,0,0] for i in range(205)]\\n self.color255= self.setColors255()\\n for i in range(205):\\n for j in range(3):\\n self.color[i][j] = self.color255[i][j]/float(255)\\n\\n return self.color\",\n \"def setColor(self, value):\\n _res = self.mAPIContext.SDGraphObjectFrame_setColor(self.mHandle, ctypes.byref(value))\\n if _res != SDApiError.NoError.value:\\n if _res == SDApiError.NoErrorOutputParamNotSet.value:\\n return None\\n raise APIException(SDApiError(_res))\\n return None\",\n \"def color(self, value: tuple) -> None:\\n if value in Color.PALETTE:\\n self._color = value\",\n \"def setColourMap(self):\\n cmap = self.config['cmap']\\n\\n pos, colour, mode = colourMaps.colourMaps(cmap)\\n\\n cmap = pg.ColorMap(pos, colour,mode)\\n self.lut = cmap.getLookupTable(0.0, 1.0, 256)\\n minsg = np.min(self.sg)\\n maxsg = np.max(self.sg)\\n self.colourStart = (self.config['brightness'] / 100.0 * self.config['contrast'] / 100.0) * (maxsg - minsg) + minsg\\n self.colourEnd = (maxsg - minsg) * (1.0 - self.config['contrast'] / 100.0) + self.colourStart\",\n \"def set_red(x, y, value, slot = 0):\\r\\n __g[slot].pixels_rgb[__g[slot].width * 3 * y + x * 3] = value\",\n \"def set_rgb(self, value):\\n act = RGBAction(self, value)\\n return act.invoke()\",\n \"def rgb_slider_moved(self, event):\\n slider_red = int(self.slider_r.get_value())\\n slider_green = int(self.slider_g.get_value())\\n slider_blue = int(self.slider_b.get_value())\\n\\n self.change_color((slider_red, slider_green, slider_blue))\",\n \"def update_color(self):\\n self.plot(update_traces=False, update_waveforms=True)\",\n \"def color_callback(self, data):\\n cv_image = self.bridge.imgmsg_to_cv2(data, desired_encoding=\\\"passthrough\\\")\\n self.color_mutex.acquire()\\n self.color_image = cv_image\\n self.color_mutex.release()\",\n \"def main():\\n # color = rb.Color.BLUE.value\\n # move_to_color(color)\\n infared_sensor()\\n\\n # WHITE/RED does not work same with the BLUE/GREEN going down\",\n \"def rgb_transition(self,r=0,g=0,b=0,duration=1,force=False):\\n r=self.assert_int_255(r)\\n g=self.assert_int_255(g)\\n b=self.assert_int_255(b)\\n #make this a no-op if we already are showing this color\\n if not force and (r==self.r and g==self.g and b==self.b):\\n return None\\n \\n tms = int(duration*1000)\\n assert tms>=0 and tms<=0xffffffff\\n t=tms.to_bytes(4,'little')\\n\\n logger.info(\\n 'Transitioning device at %03d:%03d to RGB:%02x%02x%02x over %d ms',\\n self.usbdev.bus,self.usbdev.address,r,g,b,tms)\\n ret=self.usbdev.ctrl_transfer(bmRequestType=0x21, bRequest=0x09, wValue=0x03a2, wIndex=0, data_or_wLength=[0xa2,0x00,r,g,b,t[0],t[1],t[2],t[3]])\\n self.r=r\\n self.g=g\\n self.b=b\\n return ret\",\n \"def collimator(self):\\n self.spectrum = self.spectrum\",\n \"def setColor(self, color):\\n self.__color = color\",\n \"def setChan(\\n self,\\n u,\\n chan,\\n fval,\\n ):\\n\\n self.DMX[u].set_chan_float(chan, fval)\",\n \"def setColourMap(self):\\n cmap = self.config['cmap']\\n\\n pos, colour, mode = colourMaps.colourMaps(cmap)\\n\\n cmap = pg.ColorMap(pos, colour, mode)\\n self.lut = cmap.getLookupTable(0.0, 1.0, 256)\\n minsg = np.min(self.sg)\\n maxsg = np.max(self.sg)\\n self.colourStart = (self.config['brightness'] / 100.0 * self.config['contrast'] / 100.0) * (\\n maxsg - minsg) + minsg\\n self.colourEnd = (maxsg - minsg) * (1.0 - self.config['contrast'] / 100.0) + self.colourStart\",\n \"def setColor(clr):\\n if type(clr) == types.StringType:\\n setColorString(clr)\\n return \\n if type(clr) == types.IntType:\\n setColorIndex(clr)\\n return\\n if type(clr) == types.TupleType:\\n setColorRGB(*clr)\",\n \"def map_channels(self, map_function):\\n return ScreenColor(map_function(self.red), map_function(self.green), map_function(self.blue))\",\n \"def change_color():\\n return random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)\",\n \"def setSurfaceColorScale(low,high):\\n dislin.zscale(low,high)\",\n \"def set_color(objname, rgb):\\r\\n return f'\\\\ncmd.set_color(\\\"{objname}\\\", {(rgb[0], rgb[1], rgb[2])})'\",\n \"def scale_to_01(color: C3I) -> C3F:\\n r, g, b = color\\n return r / 255, g / 255, b / 255\",\n \"def gradfactor(self, f):\\r\\n raise NotImplementedError\",\n \"def Set(*args, **kwargs):\\n return _gdi_.Colour_Set(*args, **kwargs)\",\n \"def update_r(color, new_r):\\n\\n color.update_r(new_r)\",\n \"def SetRed(self, *args):\\n return _itkRGBAPixelPython.itkRGBAPixelUS_SetRed(self, *args)\",\n \"def set_color_mode(self, mode):\\n mode=self._color_modes.get(mode,mode)\\n res=lib.is_SetColorMode(self.hcam,mode)\\n errcheck()(res,lib.is_SetColorMode,None)\\n return self.get_color_mode()\",\n \"def late_gradient_fusion():\\n pass\",\n \"def set_color(self):\\n new_color = QColorDialog.getColor(QColor(self.config['color']))\\n if not new_color.isValid():\\n return\\n self.config['color'] = new_color.rgb()\\n self.paint()\",\n \"def setColour(self, col):\\n\\t\\tself.colour = col\",\n \"def set_color(self, color):\\n self._color = color\",\n \"def set_palette(self, red, green, blue, alpha):\\n raise DitherError(\\\"Not implemented\\\")\",\n \"def change_lights_color(self, entity, attribute, oldUrl, newUrl, kwargs):\\n if newUrl != oldUrl and newUrl is not None and self.can_change_colors():\\n rgb_colors = self.get_colors(self.format_ha_url(newUrl))\\n for i in range(len(self.lights)):\\n threading.Thread(target=self.set_light_rgb, args=(self.lights[i], rgb_colors[i])).start()\",\n \"def set_red_light(self, value):\\n self.diffuse_light[0] = value\\n self.redraw()\",\n \"def setRandomColor():\\n setColor(getRandomColor())\",\n \"def set_contrast(value):\\n command([0x21, 0x14, value, 0x20, 0x0c])\",\n \"def brighter_switch(turtle, color):\\n turtle.fillcolor(color + \\\"1\\\")\",\n \"def on_rgb_slide(self,r,g,b):\\n if not self.active:\\n return\\n red = int(round(r / 100.0))\\n green = int(round(g / 100.0))\\n blue = int(round(b / 100.0))\\n self.rgb = colormodel.RGB(red, green, blue)\\n self.hsv = a3.rgb_to_hsv(self.rgb)\\n assert (self.hsv == None or type(self.hsv) == colormodel.HSV), 'rgb_to_hsv does not return a HSV object'\\n self.cmyk = a3.rgb_to_cmyk(self.rgb)\\n assert (self.cmyk == None or type(self.cmyk) == colormodel.CMYK), 'rgb_to_cmyk does not return a CMYK object'\\n self.update()\",\n \"def _color_change_mode(self):\\r\\n self.dlg.exec_()\\r\\n self.color = self.dlg.currentColor().name()\\r\\n self.colorPlate.setStyleSheet(\\\"background-color: %s;\\\" % self.color)\\r\\n self.input_scene.get_stk_color(self.color)\\r\\n return\",\n \"def color_transfert():\\n\\n\\n\\tn_target = input(\\\"Tell me which picture wants a new make up.\\\\n\\\\n\\\")\\n\\tn_source = input(\\\"And now tell me which one she wanna look like \\\\n\\\\n\\\")\\n\\n\\ttarget = cv.imread(n_target, 1)\\n\\tsource = cv.imread(n_source, 1)\\n\\n\\t### So basically, target will get new colors from source\\n\\n\\t## First let's convert them into the l alpha beta color space\\n\\n\\tt_alpha = rgb2alpha(target)\\n\\ts_alpha = rgb2alpha(source)\\n\\n\\n\\t## Now let's make up our target thanks to some statistical operations\\n\\n\\tm_target = make_up(t_alpha, s_alpha)\\n\\n\\n\\t## Finally we gonna convert target back to rgb space\\n\\n\\tm_target = alpha2rgb(m_target)\\n\\n\\t## And save it, so let's name it, you don't have to give the format, we'll add it here\\n\\n\\tname = input(\\\"What's the name of the new picture ? \\\\n\\\")\\n\\n\\tname += \\\".png\\\"\\n\\n\\tcv.imwrite(name, m_target)\\t\\t# You can now post your new picture to instagramm and let\\n\\t\\t\\t\\t\\t\\t# your followers believe that you are a skilled photograph.\\t\\n\\t\\t\\t\\t\\t\\t# I personally don't use this shit so fuck it.\\n\\n\\tprint(\\\"{} saved.\\\".format(name))\",\n \"def set_color(color='black', index=-1): # (8)\\n if index == -1:\\n global color_buffer\\n color_buffer = deque([color]*NUM_LEDS, maxlen=NUM_LEDS)\\n else:\\n color_buffer[index] = color\",\n \"def setPixelColorRGB(self, n, red, green, blue, white=0):\\n self._logger.debug(\\\"setPixelColorRGB\\\")\",\n \"def set_led_color(color):\\n requests.post('http://192.168.4.1/pixel', data=json.dumps(color))\",\n \"def fl_color(colr):\\n _fl_color = library.cfuncproto(\\n library.load_so_libforms(), \\\"fl_color\\\",\\\\\\n None, [xfdata.FL_COLOR],\\\\\\n \\\"\\\"\\\"void fl_color(FL_COLOR col)\\\"\\\"\\\")\\n library.check_if_flinitialized()\\n #library.checknonfatal_allowed_value_in_list(colr, xfdata.COLOR_list)\\n ul_colr = library.convert_to_FL_COLOR(colr)\\n library.keep_elem_refs(colr, ul_colr)\\n _fl_color(ul_colr)\",\n \"def change( p ):\\n red = p[0]\\n green = p[1]\\n blue = p[2]\\n return [ 255-red, 255-green, 255-blue ]\",\n \"def log_forward_color(self, forward_func, *args, color=None, **kwargs):\\n\\t\\tif color is None:\\n\\t\\t\\treturn forward_func(*args, **kwargs)\\n\\t\\telse:\\n\\t\\t\\tif \\\"extra\\\" not in kwargs:\\n\\t\\t\\t\\treturn forward_func(*args, extra=dict(color=color), **kwargs)\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn forward_func(*args, **{**kwargs, \\\"extra\\\": {**kwargs[\\\"extra\\\"], \\\"color\\\": color}})\",\n \"def switch(self, _color = 16):\\n\\t\\tself.pointer.flip()\\n\\n\\t\\tif self.pointer.get():\\n\\t\\t\\tself.content[0][1] = 3\\n\\t\\t\\tself.content[1][1] = 16\\n\\t\\telse:\\n\\t\\t\\tself.content[0][1] = 16\\n\\t\\t\\tself.content[1][1] = 3\",\n \"def __init__(self, target_colour: Tuple[int, int, int]) -> None:\\r\\n self.colour = target_colour\",\n \"def __init__(self, target_colour: Tuple[int, int, int]) -> None:\\r\\n self.colour = target_colour\",\n \"def __init__(self, target_colour: Tuple[int, int, int]) -> None:\\r\\n self.colour = target_colour\",\n \"def color(self, color):\\n\\n self.container['color'] = color\",\n \"def on_autocolor_switch(self, action, value):\\n\\t\\taction.set_state(value)\\n\\t\\tautocolor = value.get_boolean()\\n\\t\\tself.config[\\\"color\\\"][\\\"auto\\\"] = autocolor\\n\\n\\t\\tcolor = self.config[\\\"color\\\"][\\\"autofg\\\"] if autocolor else self.config[\\\"color\\\"][\\\"fg\\\"]\\n\\t\\tself.gui[\\\"fg-colorbutton\\\"].set_rgba(color)\\n\\t\\tself._mainapp.draw.color_update()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67156917","0.6633878","0.6617592","0.63400304","0.6332681","0.6234133","0.62047946","0.6202683","0.61825573","0.60994345","0.6095942","0.601829","0.5967596","0.5921991","0.5918888","0.5858037","0.5846267","0.5846243","0.5836248","0.5822841","0.5788105","0.5754373","0.5750509","0.5732265","0.57248926","0.5702094","0.5686844","0.5683639","0.56805426","0.5672658","0.5662928","0.5655595","0.5650803","0.56216735","0.56119525","0.5610205","0.55951834","0.559341","0.55822414","0.5568921","0.5552745","0.55457085","0.5544992","0.5528635","0.55119944","0.55037135","0.54824704","0.5469458","0.54691","0.5445954","0.5444603","0.54315346","0.5429521","0.5422716","0.54215074","0.54187334","0.5414043","0.54113674","0.5395554","0.53947955","0.53919935","0.5378827","0.5372842","0.5359309","0.53461105","0.5344184","0.534257","0.53368145","0.53322595","0.5327841","0.532369","0.5323402","0.53208464","0.53148866","0.5314142","0.530756","0.53048307","0.53042674","0.5301364","0.5296395","0.52884746","0.52848405","0.527793","0.5273372","0.5272855","0.52700037","0.5264449","0.5263763","0.5257225","0.5253555","0.52534086","0.52517337","0.52511203","0.52495605","0.5240861","0.52405316","0.52405316","0.52405316","0.52370375","0.5236274"],"string":"[\n \"0.67156917\",\n \"0.6633878\",\n \"0.6617592\",\n \"0.63400304\",\n \"0.6332681\",\n \"0.6234133\",\n \"0.62047946\",\n \"0.6202683\",\n \"0.61825573\",\n \"0.60994345\",\n \"0.6095942\",\n \"0.601829\",\n \"0.5967596\",\n \"0.5921991\",\n \"0.5918888\",\n \"0.5858037\",\n \"0.5846267\",\n \"0.5846243\",\n \"0.5836248\",\n \"0.5822841\",\n \"0.5788105\",\n \"0.5754373\",\n \"0.5750509\",\n \"0.5732265\",\n \"0.57248926\",\n \"0.5702094\",\n \"0.5686844\",\n \"0.5683639\",\n \"0.56805426\",\n \"0.5672658\",\n \"0.5662928\",\n \"0.5655595\",\n \"0.5650803\",\n \"0.56216735\",\n \"0.56119525\",\n \"0.5610205\",\n \"0.55951834\",\n \"0.559341\",\n \"0.55822414\",\n \"0.5568921\",\n \"0.5552745\",\n \"0.55457085\",\n \"0.5544992\",\n \"0.5528635\",\n \"0.55119944\",\n \"0.55037135\",\n \"0.54824704\",\n \"0.5469458\",\n \"0.54691\",\n \"0.5445954\",\n \"0.5444603\",\n \"0.54315346\",\n \"0.5429521\",\n \"0.5422716\",\n \"0.54215074\",\n \"0.54187334\",\n \"0.5414043\",\n \"0.54113674\",\n \"0.5395554\",\n \"0.53947955\",\n \"0.53919935\",\n \"0.5378827\",\n \"0.5372842\",\n \"0.5359309\",\n \"0.53461105\",\n \"0.5344184\",\n \"0.534257\",\n \"0.53368145\",\n \"0.53322595\",\n \"0.5327841\",\n \"0.532369\",\n \"0.5323402\",\n \"0.53208464\",\n \"0.53148866\",\n \"0.5314142\",\n \"0.530756\",\n \"0.53048307\",\n \"0.53042674\",\n \"0.5301364\",\n \"0.5296395\",\n \"0.52884746\",\n \"0.52848405\",\n \"0.527793\",\n \"0.5273372\",\n \"0.5272855\",\n \"0.52700037\",\n \"0.5264449\",\n \"0.5263763\",\n \"0.5257225\",\n \"0.5253555\",\n \"0.52534086\",\n \"0.52517337\",\n \"0.52511203\",\n \"0.52495605\",\n \"0.5240861\",\n \"0.52405316\",\n \"0.52405316\",\n \"0.52405316\",\n \"0.52370375\",\n \"0.5236274\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81864583"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94979,"cells":{"query":{"kind":"string","value":"Return a flag indicating whether the images are 2D or 3D images"},"document":{"kind":"string","value":"def is3DImage(self):\n\t\treturn self.is3D"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def is_depth_image(self):\n return False","def is_2d(self) -> bool:\n return self.layers == 1 and self.times == 1","def check_niimg_3d(niimg, dtype=None):\n return check_niimg(niimg, ensure_ndim=3, dtype=dtype)","def is3_d(self):\n return self.container['is3_d']","def are_compatible_imgs(one_img, another_img):\n return have_same_shapes(one_img, another_img)","def is_rgb(im):\n if(im.ndim == 3):\n return True\n else:\n return False","def test_complex(self):\n image = self.design.layout.layers[0].images[2]\n assert len(image.shape_instances) == 3","def check_img(img):\n\n if isinstance(img, (str, os.PathLike)) and os.path.exists(img):\n img = nib.load(img)\n elif not isinstance(img, nib.spatialimages.SpatialImage):\n raise TypeError('Provided image must be an existing filepath or a '\n 'pre-loaded niimg-like object')\n\n # ensure 3D or squeezable to 3D\n img = nib.funcs.squeeze_image(img)\n if len(img.shape) != 3:\n raise ValueError('Provided image must be 3D')\n\n # check if atlas data is int or castable to int\n # if image is arrayproxy convert it to an array for speed-up\n data = np.asarray(img.dataobj)\n cast = nib.is_proxy(img.dataobj)\n if img.header.get_data_dtype().kind not in ['i', 'u']:\n idata = data.astype('int32')\n cast = np.allclose(idata, data)\n data = idata\n if not cast:\n raise ValueError('Provided image should have integer values or '\n 'be safely castable to int without data loss')\n if cast:\n img = img.__class__(data, img.affine, header=img.header)\n img.header.set_data_dtype(np.int32)\n\n return img","def rgb(self) -> bool:\n return self.image_shape[2] == 3","def has_images(self):\n return len(self.images) > 0","def assertIsNifti3D(*args):\n for f in args:\n assertIsNifti(f)\n d = ensure.ensureIsImage(f)\n assert len(d.shape) == 3, \\\n 'incorrect shape for 3D nifti: {}:{}'.format(d.shape, f)","def _isGrayscale(self, img: ndarray) -> bool:\n if len(np.squeeze(img).shape) == 2:\n return True\n else:\n return False","def is_rgb(img: np.ndarray) -> bool:\n\n return len(img.shape) >= 1 and img.shape[-1] == 3","def is_lpi(image: ANTsImage) -> bool:\n return ants.get_orientation(image) == \"LPI\"","def is_RGB(self,img_path):\n image=Image.open(img_path)\n image=np.asarray(image)\n if(len(image.shape)<3):\n return False\n return True","def check_type(filename):\n try:\n im = Image.read(filename)\n except SanperaError:\n return False\n else:\n return im.original_format in [b'JPEG', b'PNG', b'GIF']","def is_grayscale(img):\n return len(img.shape) == GS","def check_image_size(img_name, img_path):\n \n try:\n \n # Open image\n img = Image.open(img_name)\n \n # Determine size of image\n width, height = img.size\n \n # Check if image is square\n if (width==height):\n is_square = True\n else:\n is_square = False\n \n # Check for channels in image\n img_list = list(img.getdata())\n img_max = max(img_list)\n if (type(img_max)==int):\n is_single_channel = True\n else:\n is_single_channel = False\n \n return is_square, is_single_channel\n \n finally:\n \n # Close image\n img.close()","def hasImages(self):\n return len(self.getImages()) > 0","def hasImages(self):\n return len(self.getImages()) > 0","def is_image(content_type):\n return content_type == \"image/jpeg\" or content_type == \"image/png\"","def images_exist(self):\n pass","def check_shape(self):\r\n if np.array(self.img).shape != (1536, 2048, 3):\r\n raise BadShape","def is_gray(img: np.ndarray):\n return len(img.shape) == 2 and img.shape[0] > 1 and img.shape[1] > 1","def number_of_images_valid():\r\n if number_of_images_a_valid() and number_of_images_b_valid():\r\n return True\r\n else:\r\n return False","def has_2D(self):\n\t\tif self.have_fastas is False:\n\t\t\tself._extract_fastas_from_fast5()\n\t\t\tself.have_fastas = True\n\n\t\tif self.fastas.get('twodirections') is not None:\n\t\t\treturn True\n\t\treturn False","def image_comparison(self):\n for result in self.cards:\n if result.image_status:\n return True\n return False","def is_image(self):\r\n # we can only get this if we have headers\r\n LOG.debug('content type')\r\n LOG.debug(self.content_type)\r\n if (self.content_type is not None and\r\n self.content_type.lower() in IMAGE_TYPES.values()):\r\n return True\r\n else:\r\n return False","def hasImages(self):\n\n if len(self._images) > 0:\n return 1\n for s in self._subdirs:\n if s.hasImages():\n return 1\n return 0","def image(self):\n return self.any_image(-1)","def isImage(imgref):\n if (imgref.endswith(\"JPG\")):\n return True\n if (imgref.endswith(\"jpg\")):\n return True\n if (imgref.endswith(\"gif\")):\n return True\n if (imgref.endswith(\"png\")):\n return True\n return False","def test_05_01_mask_of3D(self):\n x=cpi.Image()\n x.image = np.ones((10,10,3))\n self.assertTrue(x.mask.ndim==2)","def _image_is_large_enough(im):\n return (im.shape[0] >= MIN_DIM) and (im.shape[1] >= MIN_DIM)","def IsImage(self, filename):\n mimetype = mimetypes.guess_type(filename)[0]\n if not mimetype:\n return False\n return mimetype.startswith(\"image/\")","def is_valid(box, img):\n valid_width = box['top_left_x'] > 0 and box['bottom_right_x'] < img.shape[1]\n valid_height = box['top_left_y'] > 0 and box['bottom_right_y'] < img.shape[0]\n return valid_width and valid_height","def texture_mode_enabled():\n for area in bpy.context.screen.areas:\n if area.type == \"VIEW_3D\":\n for space in area.spaces:\n if space.type == \"VIEW_3D\":\n if space.viewport_shade == \"TEXTURED\":\n return True\n elif (space.viewport_shade == \"SOLID\" and\n space.show_textured_solid):\n return True\n return False","def IsImage(self, filename):\r\n mimetype = mimetypes.guess_type(filename)[0]\r\n if not mimetype:\r\n return False\r\n return mimetype.startswith(\"image/\")","def is_grayscale(self):\n return self.r == self.g == self.b","def is_grayscale(self):\n return self.r == self.g == self.b","def is3D(data):\n return data.find(\"x3\") != -1 and data.find(\"y3\") != -1 and data.find(\"z3\") != -1","def checkImageDimensions(self, filenames):\n\t\ts = None\n\t\thashStr = filenames[:]\n\t\thashStr.sort()\n\t\thashStr = str(hashStr)\n\t\t# check to see if there's already a result of the check for these filenames in the cache\n\t\tif hashStr in self.dimensionCheck:\n\t\t\tLogging.info(\"Using cached result for dimensions check: %s\"%(str(self.dimensionCheck[hashStr])))\n\t\t\treturn self.dimensionCheck[hashStr]\n\t\t\t\n\t\tfor file in filenames:\n\t\t\tif file not in self.imageDims:\n\t\t\t\tprint \"Trying to open\",type(file)\n\t\t\t\ttry:\n\t\t\t\t\tself.ext = file.split(\".\")[-1].upper()\n\t\t\t\t\tif self.ext == \"TIF\":\n\t\t\t\t\t\tself.ext = \"TIFF\"\n\t\t\t\t\tif self.ext == \"JPG\":\n\t\t\t\t\t\tself.ext = \"JPEG\"\n\n\t\t\t\t\tif self.ext == \"VTI\":\n\t\t\t\t\t\treader = vtk.vtkXMLImageReader()\n\t\t\t\t\telse:\n\t\t\t\t\t\treader = eval(\"vtk.vtk%sReader()\"%self.ext)\n\t\t\t\t\treader.SetFileName(file)\n\t\t\t\t\treader.UpdateInformation()\n\t\t\t\texcept IOError, ex:\n\t\t\t\t\ttraceback.print_exc()\n\t\t\t\t\traise Logging.GUIError(\"Cannot open image file\", \"Cannot open image file %s\" % file)\n\n\t\t\t\textent = reader.GetDataExtent()\n\t\t\t\tfSize = (extent[1],extent[3])\n\t\t\t\tself.imageDims[file] = fSize\n\t\t\telse:\n\t\t\t\tfSize = self.imageDims[file]\n\t\t\tif s and fSize != s:\n\t\t\t\tx0, y0 = s\n\t\t\t\tx1, y1 = fSize\n\t\t\t\tself.dimensionCheck[hashStr] = False\n\t\t\t\treturn 0\n\t\t\ts = fSize \n\t\t\tfn = file\n\t\tself.dimensionCheck[hashStr] = True\n\t\treturn 1","def number_of_images_a_valid():\r\n counter = 0\r\n with os.scandir(os.path.join(dir_path, \"inputs\", \"type_a\")) as filepaths:\r\n for path in filepaths:\r\n extension = os.path.splitext(path)[1].lower()\r\n if extension == \".png\" or extension == \".jpg\":\r\n counter += 1\r\n if counter >= int(number_of_images_a.get()):\r\n return True\r\n else:\r\n messagebox.showwarning(\"Invalid Image Inputs\", (\r\n \"Not enough images of type a to create \"\r\n \"requested grid.\"))\r\n return False","def check_image(image, depth):\n cols, rows = image.size\n divisor = 2**depth\n n_rows = round(rows/divisor) * divisor\n n_cols = round(cols/divisor) * divisor\n # d = min(n_rows, n_cols)\n image = image.resize((n_cols, n_rows))\n image_array = np.asarray(image)\n return image_array, Fraction(n_rows, n_cols)","def test_has_alpha(self):\n image_3d = np.array([[ # One image with shape (1, 2, 3)\n [1, 2, 3],\n [4, 5, 6]\n ]])\n image_4d = np.array([[ # One image with shape (1, 3, 4)\n [1, 2, 3, 4],\n [4, 5, 6, 7],\n [8, 9, 10, 11]\n ]])\n image_5d = np.array([[ # One image with shape (1, 1, 5)\n [1, 2, 3, 4, 5]\n ]])\n self.assertEqual(localHDR.has_alpha(image_3d), False)\n self.assertEqual(localHDR.has_alpha(image_4d), True)\n self.assertEqual(localHDR.has_alpha(image_5d), False)","def is_fit(self):\n if not hasattr(self, '_icc_imgs'):\n return False\n else:\n return self._icc_imgs is not None","def is_image_file(filename):\n img_types = [\".jpg\", \".jpeg\", \".png\", \".gif\"]\n ext = os.path.splitext(filename)[1].lower()\n return ext in img_types","def test_is_image(self):\n os.chdir(\"testimages/\")\n self.assertTrue(fileactions.is_image(\"arch_001.jpg\"))\n self.assertFalse(fileactions.is_image(\"not_an_image.jpg\"))","def check_dataset(dataset):\n loader = torch.utils.data.DataLoader(dataset, batch_size=16)\n dataiter = iter(loader)\n images, labels = dataiter.next()\n imgs_grid = make_grid(images, padding=0)\n np_grid = imgs_grid.numpy()\n plt.figure(figsize=(10, 7))\n plt.imshow(np.transpose(np_grid, (1, 2, 0)))\n for i in labels:\n print(dataset.classes[i.item()])\n plt.show()","def is_cv3():\n (major, minor, _) = cv2.__version__.split('.')\n return int(major) == 3","def _get_image_type_from_array(arr):\n if len(arr.shape) == 3 and arr.shape[2] == 3:\n # 8-bit x 3 colors\n return 'RGB'\n elif len(arr.shape) == 2:\n # 8-bit, gray-scale\n return 'L'\n else:\n raise ValueError(\n 'Input array must have either 2 dimensions or 3 dimensions where the '\n 'third dimension has 3 channels. i.e. arr.shape is (x,y) or (x,y,3). '\n 'Found shape {}.'.format(arr.shape))","def is_new_red_camera():\r\n ids = range(15)\r\n for id in ids:\r\n name = 'red{:04d}.fits'.format(id)\r\n if os.path.exists(name):\r\n hdr = pyfits.getheader(name)\r\n if hdr['NAXIS1'] == 4141 or hdr['NAXIS1'] == 4114:\r\n return True\r\n elif hdr['NAXIS1'] == 1024 or hdr['NAXIS1'] == 1124:\r\n return False\r\n else:\r\n raise ValueError('Unexpected image size')\r\n else:\r\n continue\r\n\r\n # raise ValueError('Could not locate red side files')\r\n print 'Could not locate red side files--defaulting to new camera'\r\n return True","def is_image_file(filename):\n return any([filename.endswith(img_type) for img_type in [\".jpg\", \".png\", \".gif\"]])","def is_image_file(filename):\r\n filename_lower = filename.lower()\r\n return any(filename_lower.endswith(ext) for ext in IMG_EXTENSIONS)","def countless3d(data):\n modshape = np.array(data.shape) % 2\n assert sum(\n modshape\n ) == 0, \"COUNTLESS 3D currently only supports even sided images.\" # someone has to write even_to_odd3d\n\n return countless(data, (2, 2, 2))","def images_are_present(file_info):\n currentdir = os.path.join(WORKDIR, file_info['folder'])\n if not os.path.exists(currentdir):\n return False\n count = len([x for x in os.listdir(currentdir) if x.endswith('.png')])\n if count != file_info['size']:\n print([x for x in os.listdir(currentdir) if x.endswith('.png')])\n print('Count does not match')\n print(count)\n print(file_info['size'])\n return False\n return True","def __is_image_id( self, image_id ):\n images_ids = self.__get_multi_images_ids()\n for id in images_ids:\n if image_id == id:\n return True\n return False","def load_from_images(self):\n logging.debug(\"load_from_images called\")\n return True","def create_octree_image() -> bool:\n return async_octree and (create_image_type != CREATE_IMAGE_NORMAL)","def check_image_before_load(self,image_dims):\n\n if image_dims[0]*image_dims[1]*image_dims[2]*4 < self.check_available_memory():\n return True\n else:\n return False","def check_niimg_4d(niimg, return_iterator=False, dtype=None):\n return check_niimg(\n niimg, ensure_ndim=4, return_iterator=return_iterator, dtype=dtype\n )","def is_image_landscape(asset):\r\n \r\n logging.debug('is_image_landscape({})'.format(asset))\r\n\r\n myDim = get_image_size(asset)\r\n # Calculate Width:Height; > 0 == landscape; < 0 == portrait\r\n if myDim[0]/myDim[1] > 1:\r\n logging.debug('is_image_landscape - True')\r\n return True\r\n else:\r\n logging.debug('is_image_landscape - False')\r\n return False","def no_classes(mask):\n extrema = ImageStat.Stat(mask).extrema\n r = extrema[0][1]\n g = extrema[1][1]\n b = extrema[2][1]\n\n if r == 0 and g == 0 and b == 0:\n return True\n\n return False","def __contains__(self, image: Any) -> bool:\n return isinstance(image, self.native_image_type)","def image_shape(self):\n return tuple(self._img_shape)","def is_image_size_64(image):\n return image['height'] == 64 and image['width'] == 64","def _check_images_and_labels(self, image_dir, label_dir):\n return len(os.listdir(image_dir))==len(os.listdir(label_dir))","def has_legacy_image(self):\n pass","def has_legacy_image(self):\n pass","def hasUdim(self):\n\t\treturn '<udim>' in self.path.lower()","def validate_image_type(filename: str) -> bool:\n supported_extensions = (\"png\", \"jpg\", \"jpeg\")\n return (filename not in (None, \"\")) and (get_extension(filename) in supported_extensions)","def check_layers_count(context, count):\n history = DOCKER_CLIENT.history(context.config.userdata['IMAGE'])\n if len(history) == int(count):\n return True\n\n raise Exception(\"Image does not contain %s layers, current number of layers: %s\" % (count, len(history)), history)","def isInsideImage(x, y, nx, ny, imageNx, imageNy):\r\n return ( ((x+nx) < imageNx) and ((y+ny) < imageNy) )","def image_check(kwargs) -> bool:\n\n # Kwarg argument check\n return kwarg_check(\n kwargs=kwargs,\n options=[\n \"min_captured_at\",\n \"max_captured_at\",\n \"radius\",\n \"image_type\",\n \"organization_id\",\n \"fields\",\n ],\n callback=\"image_check\",\n )","def is_image_file(filename):\n return has_file_allowed_extension(filename, IMG_EXTENSIONS)","def three_different_np_images():\n rgb1 = np.zeros((32, 32, 3), dtype=np.uint8)\n rgb1[..., 0] = 192\n rgb1[..., 1] = 0\n rgb1[..., 2] = 0\n # img1 = Image.fromarray(rgb1)\n\n rgb2 = np.zeros((32, 32, 3), dtype=np.uint8)\n rgb2[..., 0] = 0\n rgb2[..., 1] = 192\n rgb2[..., 2] = 0\n # img2 = Image.fromarray(rgb2)\n\n rgb3 = np.zeros((32, 32, 3), dtype=np.uint8)\n rgb3[..., 0] = 0\n rgb3[..., 1] = 0\n rgb3[..., 2] = 192\n # img3 = Image.fromarray(rgb3)\n\n return (rgb1, rgb2, rgb3)","def _get_consistent_shape(images: Iterable):\n dim0s = []\n dim1s = []\n\n for img in images:\n dim0s.append(img.shape[0])\n dim1s.append(img.shape[1])\n\n assert len(set(dim0s)) == 1 and len(set(dim1s)) == 1, 'Inconsistent shapes.'\n\n return dim0s[0], dim1s[0]","def compare_images(img1_path, img2_path):\n img1 = Image.open(img1_path)\n img2 = Image.open(img2_path)\n try:\n diff = ImageChops.difference(img1, img2)\n except ValueError:\n return False\n return diff.getbbox() is None","def reversible(self) -> bool:\n xy_row = np.column_stack(\n (\n np.linspace(\n -self.imgsz[0] / (2 * self.f[0]),\n self.imgsz[0] / (2 * self.f[0]),\n int(self.imgsz[0]),\n ),\n np.zeros(int(self.imgsz[0])),\n )\n )\n dxy = self._distort(xy_row)\n continuous_row = np.all(dxy[1:, 0] >= dxy[:-1, 0])\n xy_col = np.column_stack(\n (\n np.zeros(int(self.imgsz[1])),\n np.linspace(\n -self.imgsz[1] / (2 * self.f[1]),\n self.imgsz[1] / (2 * self.f[1]),\n int(self.imgsz[1]),\n ),\n )\n )\n dxy = self._distort(xy_col)\n continuous_col = np.all(dxy[1:, 1] >= dxy[:-1, 1])\n return continuous_row and continuous_col","def is_image(mine=None, file=None):\n if file:\n mine = get_file_mine(file)\n print(mine)\n if mine:\n return mine.find('image') != -1\n\n return False","def is_filetype(img_path, formats=[\"jpg\", \"png\", \"gif\", \"pgm\", \"tif\", \"ppm\"]):\n # formats = [\"jpg\", \"png\", \"gif\", \"pgm\"]\n end = img_path[-3:]\n return os.path.isfile(img_path) and (end in formats)","def isPng(self):\n\t\treturn self.extension == '.png'","def test_on_dm3_vs_dm4_image(self):\n im3 = diffread(TEST_DM3)\n im4 = diffread(TEST_DM4)\n\n with self.subTest(\"DM3\"):\n self.assertEqual(im3.shape, (2048, 2048))\n self.assertEqual(im3.dtype, np.dtype(\"int8\"))\n\n with self.subTest(\"DM4\"):\n self.assertEqual(im4.shape, (2048, 2048))\n self.assertEqual(im4.dtype, np.dtype(\"int8\"))\n\n with self.subTest(\"DM3 vs. DM4\"):\n self.assertTrue(np.allclose(im3, im4))","def get_img_shape(img):\n if K.image_dim_ordering() == 'th':\n return K.int_shape(img)\n else:\n samples, w, h, c = K.int_shape(img)\n return samples, c, w, h","def check_availability(img_path):\n # loading gray image\n gray_image = cv2.imread(img_path, 0)\n\n # check whether img give empty list or not\n flag = face_recognition.face_locations(gray_image)\n if flag:\n return True\n return False","def Has3d(self, *args):\n return _Adaptor3d.Adaptor3d_TopolTool_Has3d(self, *args)","def _check_consistency_between_imaging_extractors(self):\n return True","def IsRenderLayersOn(self):\n\n renderLayers = pm.ls(exactType=\"renderLayer\")\n referenceLayers = pm.ls(exactType=\"renderLayer\", rn=1)\n return ((len(renderLayers) - len(referenceLayers)) > 1)","def check_if_original(article):\n num_img = len(article.find_all(\"img\"))\n return num_img < 2","def hasImage(self):\n if self.getImage():\n return True\n return False","def has_image(self):\n return hasattr(self, \"_image\") and self._image is not None","def hasImg(img_name):\n try:\n Image.objects.raw({\"_id\": img_name}).first()\n return True\n except pymodm_errors.DoesNotExist:\n return False","def assertIsNifti4D(*args):\n for f in args:\n assertIsNifti(f)\n d = ensure.ensureIsImage(f)\n assert len(d.shape) == 4, \\\n 'incorrect shape for 4D nifti: {}:{}'.format(d.shape, f)","def is_image_local(self, image):\n result = self.execute_module(\"docker_image_facts\", {\"name\": image})\n return bool(result.get(\"images\")) and not result.get(\"failed\")","def has_image_data (ff_hdus_list, which_hdu=0):\n if (which_hdu == 0): # heuristic for Primary HDU\n if (ff_hdus_list[which_hdu].header.get('NAXIS') == 2):\n return True\n else:\n return False\n else: # it's an extension and so marked\n return ( (len(ff_hdus_list) > which_hdu) and\n (ff_hdus_list[which_hdu].header.get('XTENSION') == 'IMAGE') )","def checkImages(self):\r\n\r\n self.leftImage, self.rightImage, res = self.receiver.getImageData()\r\n\r\n return res","def check_sub_image(self, ndvi_filename, input_path):\n rgb_filename = re.sub(\"BWNDVI\",\"RGB\",ndvi_filename)\n rgb_img = Image.open(self.get_file(os.path.join(input_path, rgb_filename),\n self.input_location_type))\n img_ok = check_image_ok(rgb_img, 0.05)\n return img_ok","def imageType(self):\n return self.__imageType","def is_valid_image(image):\n if image not in AVAILABLE_IMAGES.keys():\n return False\n\n return True","def _check_fov(img, affine, shape):\n img = check_niimg(img)\n return img.shape[:3] == shape and np.allclose(img.affine, affine)","def is_jpg(filename):\n return '.jpg' in filename"],"string":"[\n \"def is_depth_image(self):\\n return False\",\n \"def is_2d(self) -> bool:\\n return self.layers == 1 and self.times == 1\",\n \"def check_niimg_3d(niimg, dtype=None):\\n return check_niimg(niimg, ensure_ndim=3, dtype=dtype)\",\n \"def is3_d(self):\\n return self.container['is3_d']\",\n \"def are_compatible_imgs(one_img, another_img):\\n return have_same_shapes(one_img, another_img)\",\n \"def is_rgb(im):\\n if(im.ndim == 3):\\n return True\\n else:\\n return False\",\n \"def test_complex(self):\\n image = self.design.layout.layers[0].images[2]\\n assert len(image.shape_instances) == 3\",\n \"def check_img(img):\\n\\n if isinstance(img, (str, os.PathLike)) and os.path.exists(img):\\n img = nib.load(img)\\n elif not isinstance(img, nib.spatialimages.SpatialImage):\\n raise TypeError('Provided image must be an existing filepath or a '\\n 'pre-loaded niimg-like object')\\n\\n # ensure 3D or squeezable to 3D\\n img = nib.funcs.squeeze_image(img)\\n if len(img.shape) != 3:\\n raise ValueError('Provided image must be 3D')\\n\\n # check if atlas data is int or castable to int\\n # if image is arrayproxy convert it to an array for speed-up\\n data = np.asarray(img.dataobj)\\n cast = nib.is_proxy(img.dataobj)\\n if img.header.get_data_dtype().kind not in ['i', 'u']:\\n idata = data.astype('int32')\\n cast = np.allclose(idata, data)\\n data = idata\\n if not cast:\\n raise ValueError('Provided image should have integer values or '\\n 'be safely castable to int without data loss')\\n if cast:\\n img = img.__class__(data, img.affine, header=img.header)\\n img.header.set_data_dtype(np.int32)\\n\\n return img\",\n \"def rgb(self) -> bool:\\n return self.image_shape[2] == 3\",\n \"def has_images(self):\\n return len(self.images) > 0\",\n \"def assertIsNifti3D(*args):\\n for f in args:\\n assertIsNifti(f)\\n d = ensure.ensureIsImage(f)\\n assert len(d.shape) == 3, \\\\\\n 'incorrect shape for 3D nifti: {}:{}'.format(d.shape, f)\",\n \"def _isGrayscale(self, img: ndarray) -> bool:\\n if len(np.squeeze(img).shape) == 2:\\n return True\\n else:\\n return False\",\n \"def is_rgb(img: np.ndarray) -> bool:\\n\\n return len(img.shape) >= 1 and img.shape[-1] == 3\",\n \"def is_lpi(image: ANTsImage) -> bool:\\n return ants.get_orientation(image) == \\\"LPI\\\"\",\n \"def is_RGB(self,img_path):\\n image=Image.open(img_path)\\n image=np.asarray(image)\\n if(len(image.shape)<3):\\n return False\\n return True\",\n \"def check_type(filename):\\n try:\\n im = Image.read(filename)\\n except SanperaError:\\n return False\\n else:\\n return im.original_format in [b'JPEG', b'PNG', b'GIF']\",\n \"def is_grayscale(img):\\n return len(img.shape) == GS\",\n \"def check_image_size(img_name, img_path):\\n \\n try:\\n \\n # Open image\\n img = Image.open(img_name)\\n \\n # Determine size of image\\n width, height = img.size\\n \\n # Check if image is square\\n if (width==height):\\n is_square = True\\n else:\\n is_square = False\\n \\n # Check for channels in image\\n img_list = list(img.getdata())\\n img_max = max(img_list)\\n if (type(img_max)==int):\\n is_single_channel = True\\n else:\\n is_single_channel = False\\n \\n return is_square, is_single_channel\\n \\n finally:\\n \\n # Close image\\n img.close()\",\n \"def hasImages(self):\\n return len(self.getImages()) > 0\",\n \"def hasImages(self):\\n return len(self.getImages()) > 0\",\n \"def is_image(content_type):\\n return content_type == \\\"image/jpeg\\\" or content_type == \\\"image/png\\\"\",\n \"def images_exist(self):\\n pass\",\n \"def check_shape(self):\\r\\n if np.array(self.img).shape != (1536, 2048, 3):\\r\\n raise BadShape\",\n \"def is_gray(img: np.ndarray):\\n return len(img.shape) == 2 and img.shape[0] > 1 and img.shape[1] > 1\",\n \"def number_of_images_valid():\\r\\n if number_of_images_a_valid() and number_of_images_b_valid():\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def has_2D(self):\\n\\t\\tif self.have_fastas is False:\\n\\t\\t\\tself._extract_fastas_from_fast5()\\n\\t\\t\\tself.have_fastas = True\\n\\n\\t\\tif self.fastas.get('twodirections') is not None:\\n\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def image_comparison(self):\\n for result in self.cards:\\n if result.image_status:\\n return True\\n return False\",\n \"def is_image(self):\\r\\n # we can only get this if we have headers\\r\\n LOG.debug('content type')\\r\\n LOG.debug(self.content_type)\\r\\n if (self.content_type is not None and\\r\\n self.content_type.lower() in IMAGE_TYPES.values()):\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def hasImages(self):\\n\\n if len(self._images) > 0:\\n return 1\\n for s in self._subdirs:\\n if s.hasImages():\\n return 1\\n return 0\",\n \"def image(self):\\n return self.any_image(-1)\",\n \"def isImage(imgref):\\n if (imgref.endswith(\\\"JPG\\\")):\\n return True\\n if (imgref.endswith(\\\"jpg\\\")):\\n return True\\n if (imgref.endswith(\\\"gif\\\")):\\n return True\\n if (imgref.endswith(\\\"png\\\")):\\n return True\\n return False\",\n \"def test_05_01_mask_of3D(self):\\n x=cpi.Image()\\n x.image = np.ones((10,10,3))\\n self.assertTrue(x.mask.ndim==2)\",\n \"def _image_is_large_enough(im):\\n return (im.shape[0] >= MIN_DIM) and (im.shape[1] >= MIN_DIM)\",\n \"def IsImage(self, filename):\\n mimetype = mimetypes.guess_type(filename)[0]\\n if not mimetype:\\n return False\\n return mimetype.startswith(\\\"image/\\\")\",\n \"def is_valid(box, img):\\n valid_width = box['top_left_x'] > 0 and box['bottom_right_x'] < img.shape[1]\\n valid_height = box['top_left_y'] > 0 and box['bottom_right_y'] < img.shape[0]\\n return valid_width and valid_height\",\n \"def texture_mode_enabled():\\n for area in bpy.context.screen.areas:\\n if area.type == \\\"VIEW_3D\\\":\\n for space in area.spaces:\\n if space.type == \\\"VIEW_3D\\\":\\n if space.viewport_shade == \\\"TEXTURED\\\":\\n return True\\n elif (space.viewport_shade == \\\"SOLID\\\" and\\n space.show_textured_solid):\\n return True\\n return False\",\n \"def IsImage(self, filename):\\r\\n mimetype = mimetypes.guess_type(filename)[0]\\r\\n if not mimetype:\\r\\n return False\\r\\n return mimetype.startswith(\\\"image/\\\")\",\n \"def is_grayscale(self):\\n return self.r == self.g == self.b\",\n \"def is_grayscale(self):\\n return self.r == self.g == self.b\",\n \"def is3D(data):\\n return data.find(\\\"x3\\\") != -1 and data.find(\\\"y3\\\") != -1 and data.find(\\\"z3\\\") != -1\",\n \"def checkImageDimensions(self, filenames):\\n\\t\\ts = None\\n\\t\\thashStr = filenames[:]\\n\\t\\thashStr.sort()\\n\\t\\thashStr = str(hashStr)\\n\\t\\t# check to see if there's already a result of the check for these filenames in the cache\\n\\t\\tif hashStr in self.dimensionCheck:\\n\\t\\t\\tLogging.info(\\\"Using cached result for dimensions check: %s\\\"%(str(self.dimensionCheck[hashStr])))\\n\\t\\t\\treturn self.dimensionCheck[hashStr]\\n\\t\\t\\t\\n\\t\\tfor file in filenames:\\n\\t\\t\\tif file not in self.imageDims:\\n\\t\\t\\t\\tprint \\\"Trying to open\\\",type(file)\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tself.ext = file.split(\\\".\\\")[-1].upper()\\n\\t\\t\\t\\t\\tif self.ext == \\\"TIF\\\":\\n\\t\\t\\t\\t\\t\\tself.ext = \\\"TIFF\\\"\\n\\t\\t\\t\\t\\tif self.ext == \\\"JPG\\\":\\n\\t\\t\\t\\t\\t\\tself.ext = \\\"JPEG\\\"\\n\\n\\t\\t\\t\\t\\tif self.ext == \\\"VTI\\\":\\n\\t\\t\\t\\t\\t\\treader = vtk.vtkXMLImageReader()\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\treader = eval(\\\"vtk.vtk%sReader()\\\"%self.ext)\\n\\t\\t\\t\\t\\treader.SetFileName(file)\\n\\t\\t\\t\\t\\treader.UpdateInformation()\\n\\t\\t\\t\\texcept IOError, ex:\\n\\t\\t\\t\\t\\ttraceback.print_exc()\\n\\t\\t\\t\\t\\traise Logging.GUIError(\\\"Cannot open image file\\\", \\\"Cannot open image file %s\\\" % file)\\n\\n\\t\\t\\t\\textent = reader.GetDataExtent()\\n\\t\\t\\t\\tfSize = (extent[1],extent[3])\\n\\t\\t\\t\\tself.imageDims[file] = fSize\\n\\t\\t\\telse:\\n\\t\\t\\t\\tfSize = self.imageDims[file]\\n\\t\\t\\tif s and fSize != s:\\n\\t\\t\\t\\tx0, y0 = s\\n\\t\\t\\t\\tx1, y1 = fSize\\n\\t\\t\\t\\tself.dimensionCheck[hashStr] = False\\n\\t\\t\\t\\treturn 0\\n\\t\\t\\ts = fSize \\n\\t\\t\\tfn = file\\n\\t\\tself.dimensionCheck[hashStr] = True\\n\\t\\treturn 1\",\n \"def number_of_images_a_valid():\\r\\n counter = 0\\r\\n with os.scandir(os.path.join(dir_path, \\\"inputs\\\", \\\"type_a\\\")) as filepaths:\\r\\n for path in filepaths:\\r\\n extension = os.path.splitext(path)[1].lower()\\r\\n if extension == \\\".png\\\" or extension == \\\".jpg\\\":\\r\\n counter += 1\\r\\n if counter >= int(number_of_images_a.get()):\\r\\n return True\\r\\n else:\\r\\n messagebox.showwarning(\\\"Invalid Image Inputs\\\", (\\r\\n \\\"Not enough images of type a to create \\\"\\r\\n \\\"requested grid.\\\"))\\r\\n return False\",\n \"def check_image(image, depth):\\n cols, rows = image.size\\n divisor = 2**depth\\n n_rows = round(rows/divisor) * divisor\\n n_cols = round(cols/divisor) * divisor\\n # d = min(n_rows, n_cols)\\n image = image.resize((n_cols, n_rows))\\n image_array = np.asarray(image)\\n return image_array, Fraction(n_rows, n_cols)\",\n \"def test_has_alpha(self):\\n image_3d = np.array([[ # One image with shape (1, 2, 3)\\n [1, 2, 3],\\n [4, 5, 6]\\n ]])\\n image_4d = np.array([[ # One image with shape (1, 3, 4)\\n [1, 2, 3, 4],\\n [4, 5, 6, 7],\\n [8, 9, 10, 11]\\n ]])\\n image_5d = np.array([[ # One image with shape (1, 1, 5)\\n [1, 2, 3, 4, 5]\\n ]])\\n self.assertEqual(localHDR.has_alpha(image_3d), False)\\n self.assertEqual(localHDR.has_alpha(image_4d), True)\\n self.assertEqual(localHDR.has_alpha(image_5d), False)\",\n \"def is_fit(self):\\n if not hasattr(self, '_icc_imgs'):\\n return False\\n else:\\n return self._icc_imgs is not None\",\n \"def is_image_file(filename):\\n img_types = [\\\".jpg\\\", \\\".jpeg\\\", \\\".png\\\", \\\".gif\\\"]\\n ext = os.path.splitext(filename)[1].lower()\\n return ext in img_types\",\n \"def test_is_image(self):\\n os.chdir(\\\"testimages/\\\")\\n self.assertTrue(fileactions.is_image(\\\"arch_001.jpg\\\"))\\n self.assertFalse(fileactions.is_image(\\\"not_an_image.jpg\\\"))\",\n \"def check_dataset(dataset):\\n loader = torch.utils.data.DataLoader(dataset, batch_size=16)\\n dataiter = iter(loader)\\n images, labels = dataiter.next()\\n imgs_grid = make_grid(images, padding=0)\\n np_grid = imgs_grid.numpy()\\n plt.figure(figsize=(10, 7))\\n plt.imshow(np.transpose(np_grid, (1, 2, 0)))\\n for i in labels:\\n print(dataset.classes[i.item()])\\n plt.show()\",\n \"def is_cv3():\\n (major, minor, _) = cv2.__version__.split('.')\\n return int(major) == 3\",\n \"def _get_image_type_from_array(arr):\\n if len(arr.shape) == 3 and arr.shape[2] == 3:\\n # 8-bit x 3 colors\\n return 'RGB'\\n elif len(arr.shape) == 2:\\n # 8-bit, gray-scale\\n return 'L'\\n else:\\n raise ValueError(\\n 'Input array must have either 2 dimensions or 3 dimensions where the '\\n 'third dimension has 3 channels. i.e. arr.shape is (x,y) or (x,y,3). '\\n 'Found shape {}.'.format(arr.shape))\",\n \"def is_new_red_camera():\\r\\n ids = range(15)\\r\\n for id in ids:\\r\\n name = 'red{:04d}.fits'.format(id)\\r\\n if os.path.exists(name):\\r\\n hdr = pyfits.getheader(name)\\r\\n if hdr['NAXIS1'] == 4141 or hdr['NAXIS1'] == 4114:\\r\\n return True\\r\\n elif hdr['NAXIS1'] == 1024 or hdr['NAXIS1'] == 1124:\\r\\n return False\\r\\n else:\\r\\n raise ValueError('Unexpected image size')\\r\\n else:\\r\\n continue\\r\\n\\r\\n # raise ValueError('Could not locate red side files')\\r\\n print 'Could not locate red side files--defaulting to new camera'\\r\\n return True\",\n \"def is_image_file(filename):\\n return any([filename.endswith(img_type) for img_type in [\\\".jpg\\\", \\\".png\\\", \\\".gif\\\"]])\",\n \"def is_image_file(filename):\\r\\n filename_lower = filename.lower()\\r\\n return any(filename_lower.endswith(ext) for ext in IMG_EXTENSIONS)\",\n \"def countless3d(data):\\n modshape = np.array(data.shape) % 2\\n assert sum(\\n modshape\\n ) == 0, \\\"COUNTLESS 3D currently only supports even sided images.\\\" # someone has to write even_to_odd3d\\n\\n return countless(data, (2, 2, 2))\",\n \"def images_are_present(file_info):\\n currentdir = os.path.join(WORKDIR, file_info['folder'])\\n if not os.path.exists(currentdir):\\n return False\\n count = len([x for x in os.listdir(currentdir) if x.endswith('.png')])\\n if count != file_info['size']:\\n print([x for x in os.listdir(currentdir) if x.endswith('.png')])\\n print('Count does not match')\\n print(count)\\n print(file_info['size'])\\n return False\\n return True\",\n \"def __is_image_id( self, image_id ):\\n images_ids = self.__get_multi_images_ids()\\n for id in images_ids:\\n if image_id == id:\\n return True\\n return False\",\n \"def load_from_images(self):\\n logging.debug(\\\"load_from_images called\\\")\\n return True\",\n \"def create_octree_image() -> bool:\\n return async_octree and (create_image_type != CREATE_IMAGE_NORMAL)\",\n \"def check_image_before_load(self,image_dims):\\n\\n if image_dims[0]*image_dims[1]*image_dims[2]*4 < self.check_available_memory():\\n return True\\n else:\\n return False\",\n \"def check_niimg_4d(niimg, return_iterator=False, dtype=None):\\n return check_niimg(\\n niimg, ensure_ndim=4, return_iterator=return_iterator, dtype=dtype\\n )\",\n \"def is_image_landscape(asset):\\r\\n \\r\\n logging.debug('is_image_landscape({})'.format(asset))\\r\\n\\r\\n myDim = get_image_size(asset)\\r\\n # Calculate Width:Height; > 0 == landscape; < 0 == portrait\\r\\n if myDim[0]/myDim[1] > 1:\\r\\n logging.debug('is_image_landscape - True')\\r\\n return True\\r\\n else:\\r\\n logging.debug('is_image_landscape - False')\\r\\n return False\",\n \"def no_classes(mask):\\n extrema = ImageStat.Stat(mask).extrema\\n r = extrema[0][1]\\n g = extrema[1][1]\\n b = extrema[2][1]\\n\\n if r == 0 and g == 0 and b == 0:\\n return True\\n\\n return False\",\n \"def __contains__(self, image: Any) -> bool:\\n return isinstance(image, self.native_image_type)\",\n \"def image_shape(self):\\n return tuple(self._img_shape)\",\n \"def is_image_size_64(image):\\n return image['height'] == 64 and image['width'] == 64\",\n \"def _check_images_and_labels(self, image_dir, label_dir):\\n return len(os.listdir(image_dir))==len(os.listdir(label_dir))\",\n \"def has_legacy_image(self):\\n pass\",\n \"def has_legacy_image(self):\\n pass\",\n \"def hasUdim(self):\\n\\t\\treturn '<udim>' in self.path.lower()\",\n \"def validate_image_type(filename: str) -> bool:\\n supported_extensions = (\\\"png\\\", \\\"jpg\\\", \\\"jpeg\\\")\\n return (filename not in (None, \\\"\\\")) and (get_extension(filename) in supported_extensions)\",\n \"def check_layers_count(context, count):\\n history = DOCKER_CLIENT.history(context.config.userdata['IMAGE'])\\n if len(history) == int(count):\\n return True\\n\\n raise Exception(\\\"Image does not contain %s layers, current number of layers: %s\\\" % (count, len(history)), history)\",\n \"def isInsideImage(x, y, nx, ny, imageNx, imageNy):\\r\\n return ( ((x+nx) < imageNx) and ((y+ny) < imageNy) )\",\n \"def image_check(kwargs) -> bool:\\n\\n # Kwarg argument check\\n return kwarg_check(\\n kwargs=kwargs,\\n options=[\\n \\\"min_captured_at\\\",\\n \\\"max_captured_at\\\",\\n \\\"radius\\\",\\n \\\"image_type\\\",\\n \\\"organization_id\\\",\\n \\\"fields\\\",\\n ],\\n callback=\\\"image_check\\\",\\n )\",\n \"def is_image_file(filename):\\n return has_file_allowed_extension(filename, IMG_EXTENSIONS)\",\n \"def three_different_np_images():\\n rgb1 = np.zeros((32, 32, 3), dtype=np.uint8)\\n rgb1[..., 0] = 192\\n rgb1[..., 1] = 0\\n rgb1[..., 2] = 0\\n # img1 = Image.fromarray(rgb1)\\n\\n rgb2 = np.zeros((32, 32, 3), dtype=np.uint8)\\n rgb2[..., 0] = 0\\n rgb2[..., 1] = 192\\n rgb2[..., 2] = 0\\n # img2 = Image.fromarray(rgb2)\\n\\n rgb3 = np.zeros((32, 32, 3), dtype=np.uint8)\\n rgb3[..., 0] = 0\\n rgb3[..., 1] = 0\\n rgb3[..., 2] = 192\\n # img3 = Image.fromarray(rgb3)\\n\\n return (rgb1, rgb2, rgb3)\",\n \"def _get_consistent_shape(images: Iterable):\\n dim0s = []\\n dim1s = []\\n\\n for img in images:\\n dim0s.append(img.shape[0])\\n dim1s.append(img.shape[1])\\n\\n assert len(set(dim0s)) == 1 and len(set(dim1s)) == 1, 'Inconsistent shapes.'\\n\\n return dim0s[0], dim1s[0]\",\n \"def compare_images(img1_path, img2_path):\\n img1 = Image.open(img1_path)\\n img2 = Image.open(img2_path)\\n try:\\n diff = ImageChops.difference(img1, img2)\\n except ValueError:\\n return False\\n return diff.getbbox() is None\",\n \"def reversible(self) -> bool:\\n xy_row = np.column_stack(\\n (\\n np.linspace(\\n -self.imgsz[0] / (2 * self.f[0]),\\n self.imgsz[0] / (2 * self.f[0]),\\n int(self.imgsz[0]),\\n ),\\n np.zeros(int(self.imgsz[0])),\\n )\\n )\\n dxy = self._distort(xy_row)\\n continuous_row = np.all(dxy[1:, 0] >= dxy[:-1, 0])\\n xy_col = np.column_stack(\\n (\\n np.zeros(int(self.imgsz[1])),\\n np.linspace(\\n -self.imgsz[1] / (2 * self.f[1]),\\n self.imgsz[1] / (2 * self.f[1]),\\n int(self.imgsz[1]),\\n ),\\n )\\n )\\n dxy = self._distort(xy_col)\\n continuous_col = np.all(dxy[1:, 1] >= dxy[:-1, 1])\\n return continuous_row and continuous_col\",\n \"def is_image(mine=None, file=None):\\n if file:\\n mine = get_file_mine(file)\\n print(mine)\\n if mine:\\n return mine.find('image') != -1\\n\\n return False\",\n \"def is_filetype(img_path, formats=[\\\"jpg\\\", \\\"png\\\", \\\"gif\\\", \\\"pgm\\\", \\\"tif\\\", \\\"ppm\\\"]):\\n # formats = [\\\"jpg\\\", \\\"png\\\", \\\"gif\\\", \\\"pgm\\\"]\\n end = img_path[-3:]\\n return os.path.isfile(img_path) and (end in formats)\",\n \"def isPng(self):\\n\\t\\treturn self.extension == '.png'\",\n \"def test_on_dm3_vs_dm4_image(self):\\n im3 = diffread(TEST_DM3)\\n im4 = diffread(TEST_DM4)\\n\\n with self.subTest(\\\"DM3\\\"):\\n self.assertEqual(im3.shape, (2048, 2048))\\n self.assertEqual(im3.dtype, np.dtype(\\\"int8\\\"))\\n\\n with self.subTest(\\\"DM4\\\"):\\n self.assertEqual(im4.shape, (2048, 2048))\\n self.assertEqual(im4.dtype, np.dtype(\\\"int8\\\"))\\n\\n with self.subTest(\\\"DM3 vs. DM4\\\"):\\n self.assertTrue(np.allclose(im3, im4))\",\n \"def get_img_shape(img):\\n if K.image_dim_ordering() == 'th':\\n return K.int_shape(img)\\n else:\\n samples, w, h, c = K.int_shape(img)\\n return samples, c, w, h\",\n \"def check_availability(img_path):\\n # loading gray image\\n gray_image = cv2.imread(img_path, 0)\\n\\n # check whether img give empty list or not\\n flag = face_recognition.face_locations(gray_image)\\n if flag:\\n return True\\n return False\",\n \"def Has3d(self, *args):\\n return _Adaptor3d.Adaptor3d_TopolTool_Has3d(self, *args)\",\n \"def _check_consistency_between_imaging_extractors(self):\\n return True\",\n \"def IsRenderLayersOn(self):\\n\\n renderLayers = pm.ls(exactType=\\\"renderLayer\\\")\\n referenceLayers = pm.ls(exactType=\\\"renderLayer\\\", rn=1)\\n return ((len(renderLayers) - len(referenceLayers)) > 1)\",\n \"def check_if_original(article):\\n num_img = len(article.find_all(\\\"img\\\"))\\n return num_img < 2\",\n \"def hasImage(self):\\n if self.getImage():\\n return True\\n return False\",\n \"def has_image(self):\\n return hasattr(self, \\\"_image\\\") and self._image is not None\",\n \"def hasImg(img_name):\\n try:\\n Image.objects.raw({\\\"_id\\\": img_name}).first()\\n return True\\n except pymodm_errors.DoesNotExist:\\n return False\",\n \"def assertIsNifti4D(*args):\\n for f in args:\\n assertIsNifti(f)\\n d = ensure.ensureIsImage(f)\\n assert len(d.shape) == 4, \\\\\\n 'incorrect shape for 4D nifti: {}:{}'.format(d.shape, f)\",\n \"def is_image_local(self, image):\\n result = self.execute_module(\\\"docker_image_facts\\\", {\\\"name\\\": image})\\n return bool(result.get(\\\"images\\\")) and not result.get(\\\"failed\\\")\",\n \"def has_image_data (ff_hdus_list, which_hdu=0):\\n if (which_hdu == 0): # heuristic for Primary HDU\\n if (ff_hdus_list[which_hdu].header.get('NAXIS') == 2):\\n return True\\n else:\\n return False\\n else: # it's an extension and so marked\\n return ( (len(ff_hdus_list) > which_hdu) and\\n (ff_hdus_list[which_hdu].header.get('XTENSION') == 'IMAGE') )\",\n \"def checkImages(self):\\r\\n\\r\\n self.leftImage, self.rightImage, res = self.receiver.getImageData()\\r\\n\\r\\n return res\",\n \"def check_sub_image(self, ndvi_filename, input_path):\\n rgb_filename = re.sub(\\\"BWNDVI\\\",\\\"RGB\\\",ndvi_filename)\\n rgb_img = Image.open(self.get_file(os.path.join(input_path, rgb_filename),\\n self.input_location_type))\\n img_ok = check_image_ok(rgb_img, 0.05)\\n return img_ok\",\n \"def imageType(self):\\n return self.__imageType\",\n \"def is_valid_image(image):\\n if image not in AVAILABLE_IMAGES.keys():\\n return False\\n\\n return True\",\n \"def _check_fov(img, affine, shape):\\n img = check_niimg(img)\\n return img.shape[:3] == shape and np.allclose(img.affine, affine)\",\n \"def is_jpg(filename):\\n return '.jpg' in filename\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68862396","0.65322673","0.6502295","0.64808524","0.64616615","0.64155763","0.63741845","0.6256185","0.62417966","0.6234979","0.6150245","0.6141367","0.60545796","0.6043418","0.603095","0.60253567","0.5992711","0.5932484","0.5897953","0.5897953","0.58671457","0.5839329","0.5819505","0.58014476","0.57349354","0.5710495","0.57062507","0.5704931","0.56985337","0.5688867","0.5686172","0.56808287","0.5652669","0.56464857","0.56321865","0.5617805","0.5608982","0.56055516","0.56055516","0.55936724","0.5585338","0.5585123","0.5580401","0.55687064","0.556685","0.5566292","0.55646724","0.55621666","0.55304664","0.5489376","0.5484313","0.5481332","0.54579526","0.5454903","0.54479474","0.5445142","0.5444277","0.5430202","0.5430017","0.54300165","0.54266536","0.54209954","0.54193103","0.54146785","0.5403165","0.5400727","0.5399202","0.5399202","0.53987736","0.53981996","0.53857315","0.5368322","0.5359632","0.5357035","0.53549504","0.5348926","0.53478795","0.5325552","0.53208274","0.5312523","0.5301913","0.5300684","0.5295916","0.52953595","0.5290958","0.5287248","0.5286436","0.5285352","0.5284839","0.52806103","0.52729","0.52720153","0.52689904","0.5268807","0.5262002","0.5261837","0.5261312","0.52610034","0.5260233","0.5257304"],"string":"[\n \"0.68862396\",\n \"0.65322673\",\n \"0.6502295\",\n \"0.64808524\",\n \"0.64616615\",\n \"0.64155763\",\n \"0.63741845\",\n \"0.6256185\",\n \"0.62417966\",\n \"0.6234979\",\n \"0.6150245\",\n \"0.6141367\",\n \"0.60545796\",\n \"0.6043418\",\n \"0.603095\",\n \"0.60253567\",\n \"0.5992711\",\n \"0.5932484\",\n \"0.5897953\",\n \"0.5897953\",\n \"0.58671457\",\n \"0.5839329\",\n \"0.5819505\",\n \"0.58014476\",\n \"0.57349354\",\n \"0.5710495\",\n \"0.57062507\",\n \"0.5704931\",\n \"0.56985337\",\n \"0.5688867\",\n \"0.5686172\",\n \"0.56808287\",\n \"0.5652669\",\n \"0.56464857\",\n \"0.56321865\",\n \"0.5617805\",\n \"0.5608982\",\n \"0.56055516\",\n \"0.56055516\",\n \"0.55936724\",\n \"0.5585338\",\n \"0.5585123\",\n \"0.5580401\",\n \"0.55687064\",\n \"0.556685\",\n \"0.5566292\",\n \"0.55646724\",\n \"0.55621666\",\n \"0.55304664\",\n \"0.5489376\",\n \"0.5484313\",\n \"0.5481332\",\n \"0.54579526\",\n \"0.5454903\",\n \"0.54479474\",\n \"0.5445142\",\n \"0.5444277\",\n \"0.5430202\",\n \"0.5430017\",\n \"0.54300165\",\n \"0.54266536\",\n \"0.54209954\",\n \"0.54193103\",\n \"0.54146785\",\n \"0.5403165\",\n \"0.5400727\",\n \"0.5399202\",\n \"0.5399202\",\n \"0.53987736\",\n \"0.53981996\",\n \"0.53857315\",\n \"0.5368322\",\n \"0.5359632\",\n \"0.5357035\",\n \"0.53549504\",\n \"0.5348926\",\n \"0.53478795\",\n \"0.5325552\",\n \"0.53208274\",\n \"0.5312523\",\n \"0.5301913\",\n \"0.5300684\",\n \"0.5295916\",\n \"0.52953595\",\n \"0.5290958\",\n \"0.5287248\",\n \"0.5286436\",\n \"0.5285352\",\n \"0.5284839\",\n \"0.52806103\",\n \"0.52729\",\n \"0.52720153\",\n \"0.52689904\",\n \"0.5268807\",\n \"0.5262002\",\n \"0.5261837\",\n \"0.5261312\",\n \"0.52610034\",\n \"0.5260233\",\n \"0.5257304\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7844598"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94980,"cells":{"query":{"kind":"string","value":"set the filenames that will be read"},"document":{"kind":"string","value":"def setFilenames(self, filenames):\n\t\tself.filenames = filenames\n\t\tif len(filenames) == 0:\n\t\t\treturn\n\n\t\tif not self.dimensions:\n\t\t\tself.retrieveImageInfo(filenames[0])\n\n\t\tif not self.checkImageDimensions(filenames):\n\t\t\traise Logging.GUIError(\"Image dimensions do not match\", \\\n\t\t\t\t\t\t\t\t\t\"Some of the selected files have differing dimensions, \\\n\t\t\t\t\t\t\t\t\tand cannot be imported into the same dataset.\")\t\t \n\t\tself.getReadersFromFilenames()\n\t\tself.numberOfImages = len(filenames)\n\t\tif self.is3D:\n\t\t\tif self.readers:\n\t\t\t\tself.numberOfImages = 0\n\t\t\t\tfor rdr in self.readers:\n\t\t\t\t\tself.numberOfImages += rdr.GetNumberOfSubFiles()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def set_filename(self, file_name):","def setfiles(self, filelist):\r\n self._filelist=filelist\r\n self._energy=self.readenergy(filelist)","def filenames(self):\n pass","def fileset(self):\n pass","def __init__(self, files):\n self.files = files and [NamedFile(data=d, filename=fn) for (d, fn) in files]","def setFile(self, filename):\n self.prepare() #new call on each new file to process\n self.filename = \"%s\" % filename","def set_in_files():\r\n\tindatadir = '/nobackup/ejblom/reddit'\r\n\tcom_dir = '/comments'\r\n\tsubm_dir = '/submissions'\r\n\tglob_end = '/filtered*'\r\n\tcom_glob_str = indatadir + com_dir + glob_end\r\n\tsubm_glob_str = indatadir + subm_dir + glob_end\r\n\tinfilenames = sorted(glob.glob(com_glob_str)) + sorted(glob.glob(subm_glob_str))\r\n\treturn infilenames","def load_files(self, filenames):\n self.filenames = filenames\n self.slider.setRange(0, len(self.filenames) - 1)\n self.slider.setSliderPosition(0)\n self.update_image()","def set_IDs_filenames(self):\n self._trn_IDs_file = f\"{self._ds_root}/train_{self.opts['val_split']}split.txt\"\n self._val_IDs_file = f\"{self._ds_root}/val_{self.opts['val_split']}split.txt\"\n self._tst_IDs_file = f\"{self._ds_root}/test.txt\"","def set_stations_filenames(directories):\n STATIONS.set_filenames(directories)","def _load_filenames():\n filenames = session.get('filenames')\n\n if filenames is None:\n g.filenames = None\n else:\n g.filenames = filenames","def set_filenames(self, folder_name=None):\n\n self.set_folder_name(folder_name)\n\n self.params['input_folder'] = \"%sInputSpikeTrains/\" % self.params['folder_name']# folder containing the input spike trains for the network generated from a certain stimulus\n self.params['spiketimes_folder'] = \"%sOutputSpikes/\" % self.params['folder_name']\n self.params['volt_folder'] = \"%sVoltageTraces/\" % self.params['folder_name']\n self.params['parameters_folder'] = \"%sParameters/\" % self.params['folder_name']\n self.params['connections_folder'] = \"%sConnections/\" % self.params['folder_name']\n self.params['activity_folder'] = \"%sANNActivity/\" % self.params['folder_name']\n self.params['bcpnntrace_folder'] = \"%sBcpnnTraces/\" % self.params['folder_name']\n self.params['figures_folder'] = \"%sFigures/\" % self.params['folder_name']\n self.params['movie_folder'] = \"%sMovies/\" % self.params['folder_name']\n self.params['tmp_folder'] = \"%stmp/\" % self.params['folder_name']\n self.params['data_folder'] = '%sData/' % (self.params['folder_name']) # for storage of analysis results etc\n self.params['training_input_folder'] = \"%sTrainingInput/\" % self.params['folder_name'] # folder containing the parameters used for training the network\n self.params['folder_names'] = [self.params['folder_name'], \\\n self.params['spiketimes_folder'], \\\n self.params['volt_folder'], \\\n self.params['parameters_folder'], \\\n self.params['connections_folder'], \\\n self.params['activity_folder'], \\\n self.params['bcpnntrace_folder'], \\\n self.params['figures_folder'], \\\n self.params['movie_folder'], \\\n self.params['tmp_folder'], \\\n self.params['data_folder'], \\\n self.params['training_input_folder'], \\\n self.params['input_folder']] # to be created if not yet existing\n\n self.params['params_fn_json'] = '%ssimulation_parameters.json' % (self.params['parameters_folder'])","def read_files(self):\n for f in self.filenames:\n self.games.extend(pgn.loads(open(f).read()))","def handleFileNames(self):\n \n # expand the wild cards - but do not create the full directory path\n # as the work sub directories have yet to be created.\n if not os.path.exists(self.shareArea):\n m = 'Cannot set self.auxfiles due to non-existent share directory: %s' % self.shareArea\n self.logger.fatal(m)\n raise RTTCodingError(m)\n\n # resolve auxFile patterns to file names\n auxFiles = []\n for pattern in self.auxFilePatterns:\n base, fnpattern = os.path.split(pattern)\n srcDir = os.path.normpath(os.path.join(self.shareArea, base))\n filesInShare = os.listdir(srcDir)\n auxFiles.extend([os.path.join(base,file) for file in filesInShare if fnmatch.fnmatch(file, fnpattern)])\n\n self.auxFiles = unique(auxFiles)","def select_files(self):\n pass","def __init__(self):\n self.file_list = os.listdir(self.PATH)","def _read_directory(self):\n self._filenames = glob.glob(self._directory + \"/*.project\")","def _setup_data_filenames(self):\n\n # read in filenames of training data(poses, images, labels)\n logging.info('Reading filenames')\n all_filenames = os.listdir(self.data_dir)\n if self.image_mode== ImageMode.BINARY:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.binary_im_tensor_template) > -1]\n elif self.image_mode== ImageMode.DEPTH:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.depth_im_tensor_template) > -1]\n elif self.image_mode== ImageMode.BINARY_TF:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.binary_im_tf_tensor_template) > -1]\n elif self.image_mode== ImageMode.COLOR_TF:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.color_im_tf_tensor_template) > -1]\n elif self.image_mode== ImageMode.GRAY_TF:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.gray_im_tf_tensor_template) > -1]\n elif self.image_mode== ImageMode.DEPTH_TF:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.depth_im_tf_tensor_template) > -1]\n elif self.image_mode== ImageMode.DEPTH_TF_TABLE:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.depth_im_tf_table_tensor_template) > -1]\n else:\n raise ValueError('Image mode %s not supported.' %(self.image_mode))\n\n self.pose_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.hand_poses_template) > -1]\n self.label_filenames = [f for f in all_filenames if f.find(self.target_metric_name) > -1]\n\n self.im_filenames.sort(key = lambda x: int(x[-9:-4]))\n self.pose_filenames.sort(key = lambda x: int(x[-9:-4]))\n self.label_filenames.sort(key = lambda x: int(x[-9:-4]))\n\n # check that all file categories were found\n if len(self.im_filenames) == 0 or len(self.label_filenames) == 0 or len(self.label_filenames) == 0:\n raise ValueError('1 or more required training files could not be found')","def setFileName(self, filename):\r\n #We need to extract the last position of the path. This element is the filename\r\n Splifilename = filename.split(\"\\\\\")\r\n Isofilname = Splifilename[-1]\r\n self.actualFile = Isofilname","def add_files(self, filenames):\n for filename in filenames:\n self.add_file(filename)","def change_files(self, files: list = None):\n if not is_empty_arr(files):\n self._files = files","def initialize_files(file_name, ran, file_extension):\r\n \"\"\"Specifiy the exact file name and the number of files --> file_name_(range) e.g file_name=chickens ,ran=16\"\"\"\r\n answer_file_rep = [file_name + str(number) for number in range(1, ran)]\r\n answer_files = [file + \"{}\".format(file_extension) for file in answer_file_rep]\r\n answers = [\"answer\" + str(number) for number in range(1, ran)]\r\n return answer_files, ran, answers","def get_files(self):\n def _get_files_by_names(files, name_set, postfix):\n ret = []\n for f in files: \n name = osp.basename(f).split(\"_%s\" % postfix)[0]\n if name in name_set:\n ret.append(f)\n return ret\n\n frame1_files = sorted(glob.glob(osp.join(self.root, 'images', \"*_pre_disaster*\")))\n frame2_files = sorted(glob.glob(osp.join(self.root, \"images\", \"*_post_disaster*\")))\n label_files = sorted(glob.glob(osp.join(self.root, \"masks\", \"*_change*\")))\n assert len(frame1_files) == len(frame2_files) == len(label_files), \\\n \"%d, %d, %d\" % (len(frame1_files), len(frame2_files), len(label_files))\n\n file_names = [osp.basename(f).split(\"_pre\")[0] for f in frame1_files]\n file_names = sorted(list(set(file_names)))\n if self.isTrain:\n name_set = train_test_split(file_names, train_size=0.8, random_state=0)[0]\n else: \n name_set = train_test_split(file_names, train_size=0.8, random_state=0)[1]\n self.frame1_files = _get_files_by_names(frame1_files, name_set, 'pre')\n self.frame2_files = _get_files_by_names(frame2_files, name_set, 'post')\n self.label_files = _get_files_by_names(label_files, name_set, 'change')","def set_filenames(self, directories):\n station_table_filename = self.station_table_filename\n noaa_filename = self.noaa_filename\n if directories is None:\n self.enabled = False\n self.known_stations = {}\n self.station_table_filename = ''\n self.noaa_filename = ''\n else:\n if not isinstance(directories, list):\n directories = [directories]\n self.enabled = True\n for directory in directories:\n station_table_path = os.path.join(directory, 'station.table')\n noaa_path = os.path.join(directory, 'nsd_bbsss.txt')\n if os.path.exists(station_table_path) or \\\n os.path.exists(noaa_path):\n station_table_filename = station_table_path\n noaa_filename = noaa_path\n break\n\n if station_table_filename != self.station_table_filename or \\\n noaa_filename != self.noaa_filename:\n self.station_table_filename = station_table_filename\n self.noaa_filename = noaa_filename\n self.reload()","def filenames(self) -> dict[str, str]:\r\n ...","def _load_files(self):\n for filedoc in self._docset.get_files():\n path = filedoc.get_path()\n if not path:\n # In case of only partially loaded file information,\n # the path information is not set for unloaded files.\n continue\n if not os.path.isabs(path):\n path = os.path.join(self._source_root, path)\n extension = os.path.splitext(path)[1]\n # We don't care about Markdown files that only produce pages\n # (and fail the directory check below).\n if extension == '.md':\n continue\n dirdoc = filedoc.get_directory()\n if not dirdoc:\n self._reporter.xml_assert(filedoc.get_xml_path(),\n \"file is not in any directory in Doxygen\")\n continue\n relpath = self._get_rel_path(path)\n fileobj = self._files.get(relpath)\n if not fileobj:\n fileobj = File(path, relpath, self._docmap[dirdoc])\n self._files[relpath] = fileobj\n fileobj.set_doc_xml(filedoc, self)\n self._docmap[filedoc] = fileobj","def set_files(self, items):\n if not isinstance(items, dict):\n raise ValueError('Invalid file description')\n for tid, files in items.iteritems():\n if not isinstance(files, dict):\n continue\n wanted = []\n unwanted = []\n priority_high = []\n priority_normal = []\n priority_low = []\n for fid, file in files.iteritems():\n if not isinstance(file, dict):\n continue\n if 'selected' in file and file['selected']:\n wanted.append(fid)\n else:\n unwanted.append(fid)\n if 'priority' in file:\n if file['priority'] == 'high':\n priority_high.append(fid)\n elif file['priority'] == 'normal':\n priority_normal.append(fid)\n elif file['priority'] == 'low':\n priority_low.append(fid)\n self.change([tid], files_wanted = wanted\n , files_unwanted = unwanted\n , priority_high = priority_high\n , priority_normal = priority_normal\n , priority_low = priority_low)","def get_filenames(self):\n return self.filenames","def setFile(self, filename): #$NON-NLS-1$\r","def set_files(self, file_list):\n\tif file_list==None: return []\n\timport types\n\tisString = isinstance(file_list, types.StringTypes) \n\tisList = isinstance(file_list, list) \n\tassert isString or isList, \"You should provide a list of files as list or as CVS string!\"\n\tif isList: return file_list\n\tif isString :\n\t import re\n\t file_list_converted = re.sub(r'\\s', '', file_list).split(',') #remove all whitespaces\n\t return file_list_converted","def setup(self, files):\n if not isinstance(files, (list, tuple)):\n raise RuntimeError(\"Argument must be list of files.\")\n\n self.files = files","def initFileList(self,extension):\r\n self.listExec.Clear()\r\n for fname in os.listdir(\"data\"):\r\n #print 'testing file ' , fname\r\n \r\n if extension in fname :\r\n #print fname\r\n self.listExec.Append(fname)\r\n self.Refresh()","def filepaths(self):\n pass","def set_fname_encoder(self):\n\n fp = open(self.meta_path, 'r')\n wav_names = []\n next(fp)\n for i, line in tqdm(enumerate(fp)):\n audio_name, _, _, _ = line.split()\n wav_name = os.path.basename(audio_name)\n wav_names.append(wav_name)\n self.fname_encoder.fit(wav_names)","def ingest(self, files):\n for file in files:\n self.files.add(file)","def setSourceFile(filename):","def __setupPaths(self):\n self.csv_file_names = filter(\n (lambda x: not re.match(\".*\\\\.csv$\", x) is None),\n os.listdir(self.path))","def initialize_file_readers():\n savefile_path = os.path.join(os.getcwd()+ \"/../data/\", SAVE_FILE)\n file_reader_list = []\n for file in os.listdir(savefile_path):\n file_reader = open(os.path.join(savefile_path,file), \"r\")\n file_reader_list.append({\"file_reader\": file_reader, \"last_read\": { \"word\": \"\", \"doc_score_list\": []}})\n return file_reader_list","def populate(self, dr=None):\n if dr is not None: self.directory = dr\n \n for k in OM.glob_strings:\n string =self.directory+\"/\"+OM.glob_strings[k]\n print(\"OM::populate -- Checking \",k,\" (\",string,\")\", end=\"\")\n fnames = glob.glob(string)\n print(\"... found\",len(fnames), \"files\")\n setattr(self, k, fnames)\n #print(k, lst)","def set_train_data(self):\n files_per_worker = len(self.train_list) // self.num_workers\n files_for_this_worker = self.train_list[ \n self.worker_id*files_per_worker : (self.worker_id+1)*files_per_worker ]\n # The worker takes an extra file if needed\n if self.worker_id < len(self.train_list) % self.num_workers:\n files_for_this_worker.append(self.train_list[ self.num_workers*files_per_worker + self.worker_id ])\n print \"Files for worker %d:\" % self.comm_block.Get_rank()\n for f in files_for_this_worker:\n print \" %s\" % f\n self.data.file_names = files_for_this_worker","def filelist_generator(self):\n for filename in self.filenames:\n yield filename","def files(self, ending='.sif'):\n for f in sorted(os.listdir(self.path)):\n if f.endswith(ending):\n self.file_name = f\n yield f","def __init__(self, data_dir, transform):\n self.filenames = os.listdir(data_dir)\n self.filenames = [os.path.join(data_dir, f) for f in self.filenames]\n\n self.transform = transform","def do_files(self, args):\n file_names = self.regexprutils.get_file_names()\n print 'File names:'\n for name in file_names:\n print ' %s' % (name, )","def load_files(self):\n # Needs to be implemented by child class\n raise NotImplementedError","def set_imagefilename(self,imagefilename):\n self.imagefile = open(imagefilename,'r+')","def doReadFiles(self, logicalFileName=None, realFileName=None):\n #type: (Text)->List(Text)\n assert logicalFileName or realFileName\n if logicalFileName is not None:\n self.fileName=logicalFileName\n self.sourceLines=readFileLines(\n file=self.fileName,\n issueOrigin=self,\n message='Cannot read source file %s')\n if realFileName is not None:\n self.realFileName=realFileName\n if logicalFileName==realFileName:\n self.realSourceLines=self.sourceLines\n else:\n self.realFileName = realFileName\n self.realSourceLines = readFileLines(\n file=self.realFileName,\n issueOrigin=self,\n message='Cannot read generated file %s')","def setUp(self):\n dirname = os.path.dirname(__file__)\n self.files = [\n os.path.join(dirname, 'data',\n 'goes13_IR_107_testwcm_201604291015.tif'),\n os.path.join(dirname, 'data',\n 'goes15_IR_107_testwcm_201604291015.tif'),\n os.path.join(dirname, 'data',\n 'himawari8_IR1_testwcm_201604291015.tif'),\n os.path.join(dirname, 'data',\n 'meteosat7_IR_115_testwcm_201604291015.tif'),\n os.path.join(dirname, 'data',\n 'meteosat10_IR_108_testwcm_201604291015.tif')\n ]","def set_attributes(self):\n\n self.input_file = None # the InputFile object\n self.namelist = None # the currently selected namelist\n self.file_loaded = False # is an input file loaded or not","def set_filename(self, filename):\n self._filename = filename","def getReadersFromFilenames(self):\n\t\tfor i in self.readers:\n\t\t\tdel i\n\t\tself.readers = []\n\n\t\tif not self.filenames:\n\t\t\traise Logging.GUIError(\"No files could be found\", \\\n\t\t\t\t\t\t\t\t\t\"For some reason, no files were listed to be imported.\")\t\t \n\t\t\t\t\t\n\t\tfiles = self.filenames\n\t\tprint \"Determining readers from \", self.filenames\n\n\t\tisRGB = 1\n\t\tself.ext = files[0].split(\".\")[-1].lower()\n\t\tdim = self.dimMapping[self.ext]\n\t\t# Initially flip the image if it's tiff, png or jpg.\n\t\t# In setVerticalFlip we negate the setting to have it set correctly.\n\t\tif self.ext.lower() in [\"png\", \"jpg\", \"jpeg\"]:\n\t\t\tself.flipVertically = True\n\t\tif self.ext in [\"tif\", \"tiff\"]:\n\t\t\treader = vtkbxd.vtkExtTIFFReader()\n\t\t\treader.SetFileName(files[0])\n\t\t\treader.UpdateInformation()\n\t\t\tif reader.GetNumberOfScalarComponents() >= 3:\n\t\t\t\tprint \"MODE IS RGB, IS AN RGB IMAGE\"\n\t\t\telse:\n\t\t\t\tprint \"MODE ISN'T RGB, THEREFORE NOT RGB\"\n\t\t\t\tisRGB = 0\n\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\trdr.SetFileName(files[0])\n\t\t\tif rdr.GetNumberOfSubFiles() > 1:\n\t\t\t\tdim = 3\n\t\t\t\t\n\t\tself.isRGB = isRGB\n\t\tself.is3D = (dim == 3)\n\t\t\n\t\tdirName = os.path.dirname(files[0])\n\t\tprint \"THERE ARE\", self.slicesPerTimepoint, \"SLICES PER TIMEPOINT\"\n\t\tself.ext = files[0].split(\".\")[-1].lower()\n\t\t\n\t\tif dim == 3:\n\t\t\ttotalFiles = len(files)\n\t\t\tfor i, file in enumerate(files):\n\t\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\t\trdr.SetFileName(file)\n\t\t\t\tself.readers.append(rdr)\n\t\t\treturn\n\t\t\t\n\t\ttotalFiles = len(files) / self.slicesPerTimepoint\n\n\t\timgAmnt = len(files)\n\t\tif totalFiles == 1:\n\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\tarr = vtk.vtkStringArray()\n\t\t\tfor fileName in files:\n\t\t\t\tarr.InsertNextValue(os.path.join(dirName, fileName))\n\t\t\trdr.SetFileNames(arr)\n\t\t\tself.readers.append(rdr)\n\t\t\treturn\n\t\t\t\n\t\tif imgAmnt > 1:\n\t\t\t# If the pattern doesn't have %, then we just use\n\t\t\t# the given filenames and allocate them to timepoints\n\t\t\t# using slicesPerTimepoint slices per timepoint\n\t\t\tntps = len(files) / self.slicesPerTimepoint\n\t\t\tfilelst = files[:]\n\t\t\t# dirn #TODO: what was this?\n\t\t\tfor tp in range(0, ntps):\n\t\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\t\tarr = vtk.vtkStringArray()\n\t\t\t\tfor i in range(0, self.slicesPerTimepoint):\n\t\t\t\t\tarr.InsertNextValue(filelst[0])\n\t\t\t\t\tfilelst = filelst[1:]\n\t\t\t\trdr.SetFileNames(arr)\n\t\t\t\trdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0, self.slicesPerTimepoint - 1)\n\t\t\t\trdr.SetDataSpacing(self.spacing)\n\t\t\t\trdr.SetDataOrigin(0, 0, 0)\n\t\t\t\tself.readers.append(rdr)\n\t\t\treturn\n\t\t\n\t\telif imgAmnt == 1:\n\t\t\t# If only one file\n\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\trdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0, self.slicesPerTimepoint - 1)\n\t\t\trdr.SetDataSpacing(self.spacing)\n\t\t\trdr.SetDataOrigin(0, 0, 0)\n\t\t\trdr.SetFileName(files[0])\n\n\t\t\tLogging.info(\"Reader = \", rdr, kw = \"io\")\n\t\t\tself.readers.append(rdr)","def __init__(self, root_dir):\n self.paths = glob.glob(root_dir + \"/*.csv\")\n self.target = 'Default'\n # Grouping variable names","def readdata(self, filepaths):\n pass","def GetFileNames(self):\n return self.files","def load_all_files(self):\n\t\tself.get_rankings()\n\t\tself.get_partition()\n\t\tself.__load_factors()\n\t\tself.get_document_associations()\n\t\tself.get_term_associations()","def set_filename(self, name):\n self.ds_filename = name","def addFileNames(self, fileNames):\n with Tracer(traceLogger):\n infos = []\n\n oldNumFiles = len(self.topLevelOperator.Dataset)\n # HACK: If the filePath isn't valid, replace it\n # This is to work around the scenario where two independent data selection applets are coupled, causing mutual resizes.\n # This will be fixed when a multi-file data selection applet gui replaces this gui. \n for i in reversed( range( oldNumFiles ) ):\n if not self.topLevelOperator.Dataset[i].ready():\n oldNumFiles -= 1\n else:\n break\n \n \n # Assign values to the new inputs we just allocated.\n # The GUI will be updated by callbacks that are listening to slot changes\n for i, filePath in enumerate(fileNames):\n datasetInfo = DatasetInfo()\n cwd = self.topLevelOperator.WorkingDirectory.value\n \n if not areOnSameDrive(filePath,cwd):\n QMessageBox.critical(self, \"Drive Error\",\"Data must be on same drive as working directory.\")\n return\n \n absPath, relPath = getPathVariants(filePath, cwd)\n \n # Relative by default, unless the file is in a totally different tree from the working directory.\n if len(os.path.commonprefix([cwd, absPath])) > 1:\n datasetInfo.filePath = relPath\n else:\n datasetInfo.filePath = absPath\n\n h5Exts = ['.ilp', '.h5', '.hdf5']\n if os.path.splitext(datasetInfo.filePath)[1] in h5Exts:\n datasetNames = self.getPossibleInternalPaths( absPath )\n if len(datasetNames) > 0:\n datasetInfo.filePath += str(datasetNames[0])\n else:\n raise RuntimeError(\"HDF5 file %s has no image datasets\" % datasetInfo.filePath)\n\n # Allow labels by default if this gui isn't being used for batch data.\n datasetInfo.allowLabels = ( self.guiMode == GuiMode.Normal )\n infos.append(datasetInfo)\n\n #if no exception was thrown, set up the operator now\n self.topLevelOperator.Dataset.resize( oldNumFiles+len(fileNames) )\n for i in range(len(infos)):\n self.topLevelOperator.Dataset[i+oldNumFiles].setValue( infos[i] )","def set_fnames(self, fnames):\n self.fnames = fnames[:]","def filenames(self):\n return self._filenames","def __init__(self):\n self.filelist = list()","def __set_file_info(self, path_name):\n file_name = os.path.basename(path_name)\n file_path = os.path.dirname(path_name)\n self._file_path = file_path\n self._file_name = file_name","def setup(self):\n # Call the baseclass setup to resolve any selections\n super().setup()\n\n self.outcont = None\n\n # If we are returning the same file for every iteration,\n # then load that file now.\n if self.only_prefix:\n filename = self.prefix\n\n split_ext = os.path.splitext(filename)\n if split_ext[1] not in [\".h5\", \".hdf5\"]:\n filename = split_ext[0] + \".h5\"\n\n # Load file into outcont attribute\n self.outcont = self._load_file(filename)\n\n else:\n self.prefix = os.path.splitext(self.prefix)[0]","def SetFileName(self, *args) -> \"void\":\n return _itkVTKPolyDataReaderPython.itkVTKPolyDataReaderMF3_SetFileName(self, *args)","def setup(self, files):\n if not isinstance(files, (list, tuple)):\n raise RuntimeError(\"Argument must be list of files.\")\n\n self.files = files\n\n # Set up frequency selection.\n if self.freq_physical:\n basefreq = np.linspace(800.0, 400.0, 1024, endpoint=False)\n self.freq_sel = sorted(\n set([np.argmin(np.abs(basefreq - freq)) for freq in self.freq_physical])\n )\n\n elif self.channel_range and (len(self.channel_range) <= 3):\n self.freq_sel = slice(*self.channel_range)\n\n elif self.channel_index:\n self.freq_sel = self.channel_index\n\n else:\n self.freq_sel = slice(None)","def download_files(self):","def set_file_path_name(self):\n self.file_path_name = self.get_file_path() + self.get_file_name()","def processFileNames(self, fileNames):\n inputFiles = [open(f,'r') for f in fileNames]\n try:\n datainput.processFiles(inputFiles)\n finally:\n for fp in inputFiles:\n fp.close()","def paths(self, paths):\r\n self._paths = paths\r\n self._extract()","def SetFileName(self, *args) -> \"void\":\n return _itkVTKPolyDataReaderPython.itkVTKPolyDataReaderMF2_SetFileName(self, *args)","def make_files(self):\n return []","def read(self,filenames):\n\n if isinstance(filenames, basestring):\n filenames = [filenames]\n read_ok = []\n for filename in filenames:\n try:\n fp = open(filename)\n except IOError:\n continue\n self._read(fp)\n fp.close()\n read_ok.append(filename)\n return read_ok","def associate_files(self):\n self.MatlabFiles = {'defaults': os.path.join(self.ParentDir,'defaults.m'),\n 'avevel': os.path.join(self.OutDir, 'pix2avevel.mat'),\n 'cumdef': os.path.join(self.OutDir, 'pix2cumdef.mat'),\n 'variance': os.path.join(self.OutDir, 'vaiance.mat')}","def _initNames(self):\n self.outselect = os.path.join(self.workpath, 'FT1_selected'+self.suffix+'.fits')\n self.outmktime = os.path.join(self.workpath, 'FT1_filtered'+self.suffix+'.fits')\n self.outltcube = os.path.join(self.workpath, 'LtCube'+self.suffix+'.fits')\n self.outbincub = os.path.join(self.workpath, 'BinCube'+self.suffix+'.fits')\n self.outbinmap = os.path.join(self.workpath, 'CMAP'+self.suffix+'.fits')\n self.outbinexp = os.path.join(self.workpath, 'BinExpMap'+self.suffix+'.fits')\n self.outexpmap = os.path.join(self.workpath, 'ExpMap'+self.suffix+'.fits')\n self.outsrcmap = os.path.join(self.workpath, 'SrcMaps'+self.suffix+'.fits')\n self.outgtlike = os.path.join(self.workpath, 'Results'+self.suffix+'.dat')\n self.outmodel = os.path.join(self.workpath, 'OutModel'+self.suffix+'.xml')\n self.outapert = os.path.join(self.workpath, 'LC_ApPhoto'+self.suffix+'.fits')\n self.outgtmod = os.path.join(self.workpath, 'GtModel'+self.suffix+'.fits')\n self.outresid = os.path.join(self.workpath, 'Resid'+self.suffix+'.fits')\n self.outresig = os.path.join(self.workpath, 'ResSigma'+self.suffix+'.fits')\n self.outtsmap = os.path.join(self.workpath, 'TSMmap'+self.suffix+'.fits')\n return\n # self.outfind = self.dir + self.src + '_FindSrc'+self.suffix+'.txt'","def set_paths(self, paths):\n self.paths = paths","def extract_files(self, *filenames):\n for filename in filenames:\n data = self.read_file(filename)\n f = open(filename, 'wb')\n f.write(data or b'')\n f.close()","def fixupFileNames(process):\n if not hasattr(process.source, \"fileNames\"):\n process.source.fileNames = cms.untracked.vstring()\n return","def files_set(self):\n return UploadedFile.get_files_for(self)","def listFiles(self):\n pass","def __setFileName(self,\n fileName):\n self.__fileName = fileName\n return self","def set_documents_names(cls, input_list_names: List[str]) -> None:\n cls.documents_names = input_list_names","def parse_files(self, filenames=\"\"):\n if self._parsed:\n raise Exception(\"Have been parsed\")\n self._parsed = True\n\n if filenames:\n if not isinstance(filenames, (list, tuple)):\n filenames = self._parse_string(filenames).strip(\", \").split(\",\")\n\n for filename in filenames:\n self._parse_file(filename)\n\n self._check_and_fix()","def clean_files(self):\n self.filenames.clear()","def get_tweet_file_names(self) -> None:\n self.list_of_files = os.listdir(self.input_file_path)\n no_of_files = len(self.list_of_files)\n for iterator in range(0, no_of_files):\n self.list_of_files[iterator] = self.input_file_path + \"\\\\\" + self.list_of_files[iterator]\n print(\"no of json files \",no_of_files)","def set_directories(args):\n global READS_DIR\n READS_DIR = args.reads_dir\n if not os.path.isdir(READS_DIR):\n sys.exit(\"%s not a directory\" % READS_DIR)\n READS_DIR = os.path.abspath(READS_DIR) + \"/\"\n os.chdir(READS_DIR)","def files(self):\n all_files = set()\n for label in self.filesets:\n all_files.update(self.filesets[label])\n return all_files","def _read_files(self):\n \n for langname in self.langnames:\n filename = f'data/word_lists/{langname}.txt'\n with open(filename) as f:\n index = self.langnames.index(langname)\n lang_list = getattr(self, f'word_list{index}')\n words = f.readlines()\n for word in words:\n fword = ''.join(char for char in word if char is not '\\n')\n lang_list.append(fword)\n f.close()\n return","def receiveFileFromDialog(self, paths):\n self.filesList.filesStartedLoading.emit(False)\n for p in paths:\n self.filesList.registerFile(None, QtCore.QString(p))\n self.filesList.filesFinishedLoading.emit(True)","def add_files(self, paths):\n for path in paths:\n self.add_file(path)","def setup(self, files):\n if self.acqtype not in self._acqtype_reader:\n raise ValueError(f'Specified acqtype \"{self.acqtype}\" is not supported.')\n\n if not isinstance(files, (list, tuple)):\n raise ValueError(\"Argument must be list of files.\")\n\n self.files = files","def get_files(self):\n # self.folder= +str(int(time.time()))\n if not os.path.exists(self.folder):\n os.mkdir(self.folder)\n while len(self.url_queue): # If we have URLs to crawl - we crawl\n href = self.url_queue.popleft() # We grab a URL from the left of the list\n filename = href.rsplit('/', 1)[-1]\n print(\"Downloading %s to %s...\" % (href, filename))\n fullname = os.path.join(self.folder, filename)\n urlretrieve(href, fullname)\n self.xlfnames.append(filename)","def load_data(self):\n for set_name in self.image_dir_path:\n if self.verbose:\n print('\\n> Loading data files for the set: ' + set_name)\n\n # image dir\n image_dir = os.path.join(self.data_path, self.image_dir_path[set_name])\n\n # annotation file path\n annot_filepath = os.path.join(self.data_path, self.annotation_path[set_name])\n\n if 'test' in set_name:\n yield load_data_test(set_name, image_dir, annot_filepath, self.verbose)\n else:\n yield self.load_data_trainval(set_name, image_dir, annot_filepath)","def _find_named_files(self):\n for name, description in self.named_files.iteritems():\n name = name.format(job_name=self.job_name)\n f_path = '{}/{}'.format(self.rism3d_folder, name)\n if os.path.isfile(f_path):\n self.file_path_dic[description] = f_path\n else:\n self._not_found_error(f_path)","def SetFilename(self, f):\n self._filename = f","def set_options(self, option_list):\n self._file_name = option_list['output_file'].get_value()","def __init__(self, files, **kwargs):\n self.files = {name: (None, data, 'application/octet-stream', {}) for name, data in files.iteritems()}\n for name, data in kwargs.iteritems():\n name = name.replace('_', '-')\n try:\n options = self.options_by_name[name]\n except KeyError:\n raise ValueError('Unknown option {}'.format(name))\n self.files[name] = (None, data, options.content_type, options.headers)","def setStatiFile(self, filename):\n self.statiFile = filename","def files(self):\r\n all_files = set()\r\n for label in self.filesets:\r\n all_files.update(self.filesets[label])\r\n return all_files","def files(self):\r\n all_files = set()\r\n for label in self.filesets:\r\n all_files.update(self.filesets[label])\r\n return all_files","def prepare_filenames(config: Dict[str, Any]) -> Dict[str, Any]:\n for handler_name in config[\"handlers\"].keys():\n handler_config = config[\"handlers\"][handler_name]\n if \"filename\" in handler_config:\n filename = Path(handler_config[\"filename\"]).name\n handler_config[\"filename\"] = str(LOGS_DIR.joinpath(filename))\n return config","def SetFileName(self, *args) -> \"void\":\n return _itkVTKPolyDataReaderPython.itkVTKPolyDataReaderMD3_SetFileName(self, *args)"],"string":"[\n \"def set_filename(self, file_name):\",\n \"def setfiles(self, filelist):\\r\\n self._filelist=filelist\\r\\n self._energy=self.readenergy(filelist)\",\n \"def filenames(self):\\n pass\",\n \"def fileset(self):\\n pass\",\n \"def __init__(self, files):\\n self.files = files and [NamedFile(data=d, filename=fn) for (d, fn) in files]\",\n \"def setFile(self, filename):\\n self.prepare() #new call on each new file to process\\n self.filename = \\\"%s\\\" % filename\",\n \"def set_in_files():\\r\\n\\tindatadir = '/nobackup/ejblom/reddit'\\r\\n\\tcom_dir = '/comments'\\r\\n\\tsubm_dir = '/submissions'\\r\\n\\tglob_end = '/filtered*'\\r\\n\\tcom_glob_str = indatadir + com_dir + glob_end\\r\\n\\tsubm_glob_str = indatadir + subm_dir + glob_end\\r\\n\\tinfilenames = sorted(glob.glob(com_glob_str)) + sorted(glob.glob(subm_glob_str))\\r\\n\\treturn infilenames\",\n \"def load_files(self, filenames):\\n self.filenames = filenames\\n self.slider.setRange(0, len(self.filenames) - 1)\\n self.slider.setSliderPosition(0)\\n self.update_image()\",\n \"def set_IDs_filenames(self):\\n self._trn_IDs_file = f\\\"{self._ds_root}/train_{self.opts['val_split']}split.txt\\\"\\n self._val_IDs_file = f\\\"{self._ds_root}/val_{self.opts['val_split']}split.txt\\\"\\n self._tst_IDs_file = f\\\"{self._ds_root}/test.txt\\\"\",\n \"def set_stations_filenames(directories):\\n STATIONS.set_filenames(directories)\",\n \"def _load_filenames():\\n filenames = session.get('filenames')\\n\\n if filenames is None:\\n g.filenames = None\\n else:\\n g.filenames = filenames\",\n \"def set_filenames(self, folder_name=None):\\n\\n self.set_folder_name(folder_name)\\n\\n self.params['input_folder'] = \\\"%sInputSpikeTrains/\\\" % self.params['folder_name']# folder containing the input spike trains for the network generated from a certain stimulus\\n self.params['spiketimes_folder'] = \\\"%sOutputSpikes/\\\" % self.params['folder_name']\\n self.params['volt_folder'] = \\\"%sVoltageTraces/\\\" % self.params['folder_name']\\n self.params['parameters_folder'] = \\\"%sParameters/\\\" % self.params['folder_name']\\n self.params['connections_folder'] = \\\"%sConnections/\\\" % self.params['folder_name']\\n self.params['activity_folder'] = \\\"%sANNActivity/\\\" % self.params['folder_name']\\n self.params['bcpnntrace_folder'] = \\\"%sBcpnnTraces/\\\" % self.params['folder_name']\\n self.params['figures_folder'] = \\\"%sFigures/\\\" % self.params['folder_name']\\n self.params['movie_folder'] = \\\"%sMovies/\\\" % self.params['folder_name']\\n self.params['tmp_folder'] = \\\"%stmp/\\\" % self.params['folder_name']\\n self.params['data_folder'] = '%sData/' % (self.params['folder_name']) # for storage of analysis results etc\\n self.params['training_input_folder'] = \\\"%sTrainingInput/\\\" % self.params['folder_name'] # folder containing the parameters used for training the network\\n self.params['folder_names'] = [self.params['folder_name'], \\\\\\n self.params['spiketimes_folder'], \\\\\\n self.params['volt_folder'], \\\\\\n self.params['parameters_folder'], \\\\\\n self.params['connections_folder'], \\\\\\n self.params['activity_folder'], \\\\\\n self.params['bcpnntrace_folder'], \\\\\\n self.params['figures_folder'], \\\\\\n self.params['movie_folder'], \\\\\\n self.params['tmp_folder'], \\\\\\n self.params['data_folder'], \\\\\\n self.params['training_input_folder'], \\\\\\n self.params['input_folder']] # to be created if not yet existing\\n\\n self.params['params_fn_json'] = '%ssimulation_parameters.json' % (self.params['parameters_folder'])\",\n \"def read_files(self):\\n for f in self.filenames:\\n self.games.extend(pgn.loads(open(f).read()))\",\n \"def handleFileNames(self):\\n \\n # expand the wild cards - but do not create the full directory path\\n # as the work sub directories have yet to be created.\\n if not os.path.exists(self.shareArea):\\n m = 'Cannot set self.auxfiles due to non-existent share directory: %s' % self.shareArea\\n self.logger.fatal(m)\\n raise RTTCodingError(m)\\n\\n # resolve auxFile patterns to file names\\n auxFiles = []\\n for pattern in self.auxFilePatterns:\\n base, fnpattern = os.path.split(pattern)\\n srcDir = os.path.normpath(os.path.join(self.shareArea, base))\\n filesInShare = os.listdir(srcDir)\\n auxFiles.extend([os.path.join(base,file) for file in filesInShare if fnmatch.fnmatch(file, fnpattern)])\\n\\n self.auxFiles = unique(auxFiles)\",\n \"def select_files(self):\\n pass\",\n \"def __init__(self):\\n self.file_list = os.listdir(self.PATH)\",\n \"def _read_directory(self):\\n self._filenames = glob.glob(self._directory + \\\"/*.project\\\")\",\n \"def _setup_data_filenames(self):\\n\\n # read in filenames of training data(poses, images, labels)\\n logging.info('Reading filenames')\\n all_filenames = os.listdir(self.data_dir)\\n if self.image_mode== ImageMode.BINARY:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.binary_im_tensor_template) > -1]\\n elif self.image_mode== ImageMode.DEPTH:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.depth_im_tensor_template) > -1]\\n elif self.image_mode== ImageMode.BINARY_TF:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.binary_im_tf_tensor_template) > -1]\\n elif self.image_mode== ImageMode.COLOR_TF:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.color_im_tf_tensor_template) > -1]\\n elif self.image_mode== ImageMode.GRAY_TF:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.gray_im_tf_tensor_template) > -1]\\n elif self.image_mode== ImageMode.DEPTH_TF:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.depth_im_tf_tensor_template) > -1]\\n elif self.image_mode== ImageMode.DEPTH_TF_TABLE:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.depth_im_tf_table_tensor_template) > -1]\\n else:\\n raise ValueError('Image mode %s not supported.' %(self.image_mode))\\n\\n self.pose_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.hand_poses_template) > -1]\\n self.label_filenames = [f for f in all_filenames if f.find(self.target_metric_name) > -1]\\n\\n self.im_filenames.sort(key = lambda x: int(x[-9:-4]))\\n self.pose_filenames.sort(key = lambda x: int(x[-9:-4]))\\n self.label_filenames.sort(key = lambda x: int(x[-9:-4]))\\n\\n # check that all file categories were found\\n if len(self.im_filenames) == 0 or len(self.label_filenames) == 0 or len(self.label_filenames) == 0:\\n raise ValueError('1 or more required training files could not be found')\",\n \"def setFileName(self, filename):\\r\\n #We need to extract the last position of the path. This element is the filename\\r\\n Splifilename = filename.split(\\\"\\\\\\\\\\\")\\r\\n Isofilname = Splifilename[-1]\\r\\n self.actualFile = Isofilname\",\n \"def add_files(self, filenames):\\n for filename in filenames:\\n self.add_file(filename)\",\n \"def change_files(self, files: list = None):\\n if not is_empty_arr(files):\\n self._files = files\",\n \"def initialize_files(file_name, ran, file_extension):\\r\\n \\\"\\\"\\\"Specifiy the exact file name and the number of files --> file_name_(range) e.g file_name=chickens ,ran=16\\\"\\\"\\\"\\r\\n answer_file_rep = [file_name + str(number) for number in range(1, ran)]\\r\\n answer_files = [file + \\\"{}\\\".format(file_extension) for file in answer_file_rep]\\r\\n answers = [\\\"answer\\\" + str(number) for number in range(1, ran)]\\r\\n return answer_files, ran, answers\",\n \"def get_files(self):\\n def _get_files_by_names(files, name_set, postfix):\\n ret = []\\n for f in files: \\n name = osp.basename(f).split(\\\"_%s\\\" % postfix)[0]\\n if name in name_set:\\n ret.append(f)\\n return ret\\n\\n frame1_files = sorted(glob.glob(osp.join(self.root, 'images', \\\"*_pre_disaster*\\\")))\\n frame2_files = sorted(glob.glob(osp.join(self.root, \\\"images\\\", \\\"*_post_disaster*\\\")))\\n label_files = sorted(glob.glob(osp.join(self.root, \\\"masks\\\", \\\"*_change*\\\")))\\n assert len(frame1_files) == len(frame2_files) == len(label_files), \\\\\\n \\\"%d, %d, %d\\\" % (len(frame1_files), len(frame2_files), len(label_files))\\n\\n file_names = [osp.basename(f).split(\\\"_pre\\\")[0] for f in frame1_files]\\n file_names = sorted(list(set(file_names)))\\n if self.isTrain:\\n name_set = train_test_split(file_names, train_size=0.8, random_state=0)[0]\\n else: \\n name_set = train_test_split(file_names, train_size=0.8, random_state=0)[1]\\n self.frame1_files = _get_files_by_names(frame1_files, name_set, 'pre')\\n self.frame2_files = _get_files_by_names(frame2_files, name_set, 'post')\\n self.label_files = _get_files_by_names(label_files, name_set, 'change')\",\n \"def set_filenames(self, directories):\\n station_table_filename = self.station_table_filename\\n noaa_filename = self.noaa_filename\\n if directories is None:\\n self.enabled = False\\n self.known_stations = {}\\n self.station_table_filename = ''\\n self.noaa_filename = ''\\n else:\\n if not isinstance(directories, list):\\n directories = [directories]\\n self.enabled = True\\n for directory in directories:\\n station_table_path = os.path.join(directory, 'station.table')\\n noaa_path = os.path.join(directory, 'nsd_bbsss.txt')\\n if os.path.exists(station_table_path) or \\\\\\n os.path.exists(noaa_path):\\n station_table_filename = station_table_path\\n noaa_filename = noaa_path\\n break\\n\\n if station_table_filename != self.station_table_filename or \\\\\\n noaa_filename != self.noaa_filename:\\n self.station_table_filename = station_table_filename\\n self.noaa_filename = noaa_filename\\n self.reload()\",\n \"def filenames(self) -> dict[str, str]:\\r\\n ...\",\n \"def _load_files(self):\\n for filedoc in self._docset.get_files():\\n path = filedoc.get_path()\\n if not path:\\n # In case of only partially loaded file information,\\n # the path information is not set for unloaded files.\\n continue\\n if not os.path.isabs(path):\\n path = os.path.join(self._source_root, path)\\n extension = os.path.splitext(path)[1]\\n # We don't care about Markdown files that only produce pages\\n # (and fail the directory check below).\\n if extension == '.md':\\n continue\\n dirdoc = filedoc.get_directory()\\n if not dirdoc:\\n self._reporter.xml_assert(filedoc.get_xml_path(),\\n \\\"file is not in any directory in Doxygen\\\")\\n continue\\n relpath = self._get_rel_path(path)\\n fileobj = self._files.get(relpath)\\n if not fileobj:\\n fileobj = File(path, relpath, self._docmap[dirdoc])\\n self._files[relpath] = fileobj\\n fileobj.set_doc_xml(filedoc, self)\\n self._docmap[filedoc] = fileobj\",\n \"def set_files(self, items):\\n if not isinstance(items, dict):\\n raise ValueError('Invalid file description')\\n for tid, files in items.iteritems():\\n if not isinstance(files, dict):\\n continue\\n wanted = []\\n unwanted = []\\n priority_high = []\\n priority_normal = []\\n priority_low = []\\n for fid, file in files.iteritems():\\n if not isinstance(file, dict):\\n continue\\n if 'selected' in file and file['selected']:\\n wanted.append(fid)\\n else:\\n unwanted.append(fid)\\n if 'priority' in file:\\n if file['priority'] == 'high':\\n priority_high.append(fid)\\n elif file['priority'] == 'normal':\\n priority_normal.append(fid)\\n elif file['priority'] == 'low':\\n priority_low.append(fid)\\n self.change([tid], files_wanted = wanted\\n , files_unwanted = unwanted\\n , priority_high = priority_high\\n , priority_normal = priority_normal\\n , priority_low = priority_low)\",\n \"def get_filenames(self):\\n return self.filenames\",\n \"def setFile(self, filename): #$NON-NLS-1$\\r\",\n \"def set_files(self, file_list):\\n\\tif file_list==None: return []\\n\\timport types\\n\\tisString = isinstance(file_list, types.StringTypes) \\n\\tisList = isinstance(file_list, list) \\n\\tassert isString or isList, \\\"You should provide a list of files as list or as CVS string!\\\"\\n\\tif isList: return file_list\\n\\tif isString :\\n\\t import re\\n\\t file_list_converted = re.sub(r'\\\\s', '', file_list).split(',') #remove all whitespaces\\n\\t return file_list_converted\",\n \"def setup(self, files):\\n if not isinstance(files, (list, tuple)):\\n raise RuntimeError(\\\"Argument must be list of files.\\\")\\n\\n self.files = files\",\n \"def initFileList(self,extension):\\r\\n self.listExec.Clear()\\r\\n for fname in os.listdir(\\\"data\\\"):\\r\\n #print 'testing file ' , fname\\r\\n \\r\\n if extension in fname :\\r\\n #print fname\\r\\n self.listExec.Append(fname)\\r\\n self.Refresh()\",\n \"def filepaths(self):\\n pass\",\n \"def set_fname_encoder(self):\\n\\n fp = open(self.meta_path, 'r')\\n wav_names = []\\n next(fp)\\n for i, line in tqdm(enumerate(fp)):\\n audio_name, _, _, _ = line.split()\\n wav_name = os.path.basename(audio_name)\\n wav_names.append(wav_name)\\n self.fname_encoder.fit(wav_names)\",\n \"def ingest(self, files):\\n for file in files:\\n self.files.add(file)\",\n \"def setSourceFile(filename):\",\n \"def __setupPaths(self):\\n self.csv_file_names = filter(\\n (lambda x: not re.match(\\\".*\\\\\\\\.csv$\\\", x) is None),\\n os.listdir(self.path))\",\n \"def initialize_file_readers():\\n savefile_path = os.path.join(os.getcwd()+ \\\"/../data/\\\", SAVE_FILE)\\n file_reader_list = []\\n for file in os.listdir(savefile_path):\\n file_reader = open(os.path.join(savefile_path,file), \\\"r\\\")\\n file_reader_list.append({\\\"file_reader\\\": file_reader, \\\"last_read\\\": { \\\"word\\\": \\\"\\\", \\\"doc_score_list\\\": []}})\\n return file_reader_list\",\n \"def populate(self, dr=None):\\n if dr is not None: self.directory = dr\\n \\n for k in OM.glob_strings:\\n string =self.directory+\\\"/\\\"+OM.glob_strings[k]\\n print(\\\"OM::populate -- Checking \\\",k,\\\" (\\\",string,\\\")\\\", end=\\\"\\\")\\n fnames = glob.glob(string)\\n print(\\\"... found\\\",len(fnames), \\\"files\\\")\\n setattr(self, k, fnames)\\n #print(k, lst)\",\n \"def set_train_data(self):\\n files_per_worker = len(self.train_list) // self.num_workers\\n files_for_this_worker = self.train_list[ \\n self.worker_id*files_per_worker : (self.worker_id+1)*files_per_worker ]\\n # The worker takes an extra file if needed\\n if self.worker_id < len(self.train_list) % self.num_workers:\\n files_for_this_worker.append(self.train_list[ self.num_workers*files_per_worker + self.worker_id ])\\n print \\\"Files for worker %d:\\\" % self.comm_block.Get_rank()\\n for f in files_for_this_worker:\\n print \\\" %s\\\" % f\\n self.data.file_names = files_for_this_worker\",\n \"def filelist_generator(self):\\n for filename in self.filenames:\\n yield filename\",\n \"def files(self, ending='.sif'):\\n for f in sorted(os.listdir(self.path)):\\n if f.endswith(ending):\\n self.file_name = f\\n yield f\",\n \"def __init__(self, data_dir, transform):\\n self.filenames = os.listdir(data_dir)\\n self.filenames = [os.path.join(data_dir, f) for f in self.filenames]\\n\\n self.transform = transform\",\n \"def do_files(self, args):\\n file_names = self.regexprutils.get_file_names()\\n print 'File names:'\\n for name in file_names:\\n print ' %s' % (name, )\",\n \"def load_files(self):\\n # Needs to be implemented by child class\\n raise NotImplementedError\",\n \"def set_imagefilename(self,imagefilename):\\n self.imagefile = open(imagefilename,'r+')\",\n \"def doReadFiles(self, logicalFileName=None, realFileName=None):\\n #type: (Text)->List(Text)\\n assert logicalFileName or realFileName\\n if logicalFileName is not None:\\n self.fileName=logicalFileName\\n self.sourceLines=readFileLines(\\n file=self.fileName,\\n issueOrigin=self,\\n message='Cannot read source file %s')\\n if realFileName is not None:\\n self.realFileName=realFileName\\n if logicalFileName==realFileName:\\n self.realSourceLines=self.sourceLines\\n else:\\n self.realFileName = realFileName\\n self.realSourceLines = readFileLines(\\n file=self.realFileName,\\n issueOrigin=self,\\n message='Cannot read generated file %s')\",\n \"def setUp(self):\\n dirname = os.path.dirname(__file__)\\n self.files = [\\n os.path.join(dirname, 'data',\\n 'goes13_IR_107_testwcm_201604291015.tif'),\\n os.path.join(dirname, 'data',\\n 'goes15_IR_107_testwcm_201604291015.tif'),\\n os.path.join(dirname, 'data',\\n 'himawari8_IR1_testwcm_201604291015.tif'),\\n os.path.join(dirname, 'data',\\n 'meteosat7_IR_115_testwcm_201604291015.tif'),\\n os.path.join(dirname, 'data',\\n 'meteosat10_IR_108_testwcm_201604291015.tif')\\n ]\",\n \"def set_attributes(self):\\n\\n self.input_file = None # the InputFile object\\n self.namelist = None # the currently selected namelist\\n self.file_loaded = False # is an input file loaded or not\",\n \"def set_filename(self, filename):\\n self._filename = filename\",\n \"def getReadersFromFilenames(self):\\n\\t\\tfor i in self.readers:\\n\\t\\t\\tdel i\\n\\t\\tself.readers = []\\n\\n\\t\\tif not self.filenames:\\n\\t\\t\\traise Logging.GUIError(\\\"No files could be found\\\", \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"For some reason, no files were listed to be imported.\\\")\\t\\t \\n\\t\\t\\t\\t\\t\\n\\t\\tfiles = self.filenames\\n\\t\\tprint \\\"Determining readers from \\\", self.filenames\\n\\n\\t\\tisRGB = 1\\n\\t\\tself.ext = files[0].split(\\\".\\\")[-1].lower()\\n\\t\\tdim = self.dimMapping[self.ext]\\n\\t\\t# Initially flip the image if it's tiff, png or jpg.\\n\\t\\t# In setVerticalFlip we negate the setting to have it set correctly.\\n\\t\\tif self.ext.lower() in [\\\"png\\\", \\\"jpg\\\", \\\"jpeg\\\"]:\\n\\t\\t\\tself.flipVertically = True\\n\\t\\tif self.ext in [\\\"tif\\\", \\\"tiff\\\"]:\\n\\t\\t\\treader = vtkbxd.vtkExtTIFFReader()\\n\\t\\t\\treader.SetFileName(files[0])\\n\\t\\t\\treader.UpdateInformation()\\n\\t\\t\\tif reader.GetNumberOfScalarComponents() >= 3:\\n\\t\\t\\t\\tprint \\\"MODE IS RGB, IS AN RGB IMAGE\\\"\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprint \\\"MODE ISN'T RGB, THEREFORE NOT RGB\\\"\\n\\t\\t\\t\\tisRGB = 0\\n\\t\\t\\trdr = self.getReaderByExtension(self.ext, isRGB)\\n\\t\\t\\trdr.SetFileName(files[0])\\n\\t\\t\\tif rdr.GetNumberOfSubFiles() > 1:\\n\\t\\t\\t\\tdim = 3\\n\\t\\t\\t\\t\\n\\t\\tself.isRGB = isRGB\\n\\t\\tself.is3D = (dim == 3)\\n\\t\\t\\n\\t\\tdirName = os.path.dirname(files[0])\\n\\t\\tprint \\\"THERE ARE\\\", self.slicesPerTimepoint, \\\"SLICES PER TIMEPOINT\\\"\\n\\t\\tself.ext = files[0].split(\\\".\\\")[-1].lower()\\n\\t\\t\\n\\t\\tif dim == 3:\\n\\t\\t\\ttotalFiles = len(files)\\n\\t\\t\\tfor i, file in enumerate(files):\\n\\t\\t\\t\\trdr = self.getReaderByExtension(self.ext, isRGB)\\n\\t\\t\\t\\trdr.SetFileName(file)\\n\\t\\t\\t\\tself.readers.append(rdr)\\n\\t\\t\\treturn\\n\\t\\t\\t\\n\\t\\ttotalFiles = len(files) / self.slicesPerTimepoint\\n\\n\\t\\timgAmnt = len(files)\\n\\t\\tif totalFiles == 1:\\n\\t\\t\\trdr = self.getReaderByExtension(self.ext, isRGB)\\n\\t\\t\\tarr = vtk.vtkStringArray()\\n\\t\\t\\tfor fileName in files:\\n\\t\\t\\t\\tarr.InsertNextValue(os.path.join(dirName, fileName))\\n\\t\\t\\trdr.SetFileNames(arr)\\n\\t\\t\\tself.readers.append(rdr)\\n\\t\\t\\treturn\\n\\t\\t\\t\\n\\t\\tif imgAmnt > 1:\\n\\t\\t\\t# If the pattern doesn't have %, then we just use\\n\\t\\t\\t# the given filenames and allocate them to timepoints\\n\\t\\t\\t# using slicesPerTimepoint slices per timepoint\\n\\t\\t\\tntps = len(files) / self.slicesPerTimepoint\\n\\t\\t\\tfilelst = files[:]\\n\\t\\t\\t# dirn #TODO: what was this?\\n\\t\\t\\tfor tp in range(0, ntps):\\n\\t\\t\\t\\trdr = self.getReaderByExtension(self.ext, isRGB)\\n\\t\\t\\t\\tarr = vtk.vtkStringArray()\\n\\t\\t\\t\\tfor i in range(0, self.slicesPerTimepoint):\\n\\t\\t\\t\\t\\tarr.InsertNextValue(filelst[0])\\n\\t\\t\\t\\t\\tfilelst = filelst[1:]\\n\\t\\t\\t\\trdr.SetFileNames(arr)\\n\\t\\t\\t\\trdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0, self.slicesPerTimepoint - 1)\\n\\t\\t\\t\\trdr.SetDataSpacing(self.spacing)\\n\\t\\t\\t\\trdr.SetDataOrigin(0, 0, 0)\\n\\t\\t\\t\\tself.readers.append(rdr)\\n\\t\\t\\treturn\\n\\t\\t\\n\\t\\telif imgAmnt == 1:\\n\\t\\t\\t# If only one file\\n\\t\\t\\trdr = self.getReaderByExtension(self.ext, isRGB)\\n\\t\\t\\trdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0, self.slicesPerTimepoint - 1)\\n\\t\\t\\trdr.SetDataSpacing(self.spacing)\\n\\t\\t\\trdr.SetDataOrigin(0, 0, 0)\\n\\t\\t\\trdr.SetFileName(files[0])\\n\\n\\t\\t\\tLogging.info(\\\"Reader = \\\", rdr, kw = \\\"io\\\")\\n\\t\\t\\tself.readers.append(rdr)\",\n \"def __init__(self, root_dir):\\n self.paths = glob.glob(root_dir + \\\"/*.csv\\\")\\n self.target = 'Default'\\n # Grouping variable names\",\n \"def readdata(self, filepaths):\\n pass\",\n \"def GetFileNames(self):\\n return self.files\",\n \"def load_all_files(self):\\n\\t\\tself.get_rankings()\\n\\t\\tself.get_partition()\\n\\t\\tself.__load_factors()\\n\\t\\tself.get_document_associations()\\n\\t\\tself.get_term_associations()\",\n \"def set_filename(self, name):\\n self.ds_filename = name\",\n \"def addFileNames(self, fileNames):\\n with Tracer(traceLogger):\\n infos = []\\n\\n oldNumFiles = len(self.topLevelOperator.Dataset)\\n # HACK: If the filePath isn't valid, replace it\\n # This is to work around the scenario where two independent data selection applets are coupled, causing mutual resizes.\\n # This will be fixed when a multi-file data selection applet gui replaces this gui. \\n for i in reversed( range( oldNumFiles ) ):\\n if not self.topLevelOperator.Dataset[i].ready():\\n oldNumFiles -= 1\\n else:\\n break\\n \\n \\n # Assign values to the new inputs we just allocated.\\n # The GUI will be updated by callbacks that are listening to slot changes\\n for i, filePath in enumerate(fileNames):\\n datasetInfo = DatasetInfo()\\n cwd = self.topLevelOperator.WorkingDirectory.value\\n \\n if not areOnSameDrive(filePath,cwd):\\n QMessageBox.critical(self, \\\"Drive Error\\\",\\\"Data must be on same drive as working directory.\\\")\\n return\\n \\n absPath, relPath = getPathVariants(filePath, cwd)\\n \\n # Relative by default, unless the file is in a totally different tree from the working directory.\\n if len(os.path.commonprefix([cwd, absPath])) > 1:\\n datasetInfo.filePath = relPath\\n else:\\n datasetInfo.filePath = absPath\\n\\n h5Exts = ['.ilp', '.h5', '.hdf5']\\n if os.path.splitext(datasetInfo.filePath)[1] in h5Exts:\\n datasetNames = self.getPossibleInternalPaths( absPath )\\n if len(datasetNames) > 0:\\n datasetInfo.filePath += str(datasetNames[0])\\n else:\\n raise RuntimeError(\\\"HDF5 file %s has no image datasets\\\" % datasetInfo.filePath)\\n\\n # Allow labels by default if this gui isn't being used for batch data.\\n datasetInfo.allowLabels = ( self.guiMode == GuiMode.Normal )\\n infos.append(datasetInfo)\\n\\n #if no exception was thrown, set up the operator now\\n self.topLevelOperator.Dataset.resize( oldNumFiles+len(fileNames) )\\n for i in range(len(infos)):\\n self.topLevelOperator.Dataset[i+oldNumFiles].setValue( infos[i] )\",\n \"def set_fnames(self, fnames):\\n self.fnames = fnames[:]\",\n \"def filenames(self):\\n return self._filenames\",\n \"def __init__(self):\\n self.filelist = list()\",\n \"def __set_file_info(self, path_name):\\n file_name = os.path.basename(path_name)\\n file_path = os.path.dirname(path_name)\\n self._file_path = file_path\\n self._file_name = file_name\",\n \"def setup(self):\\n # Call the baseclass setup to resolve any selections\\n super().setup()\\n\\n self.outcont = None\\n\\n # If we are returning the same file for every iteration,\\n # then load that file now.\\n if self.only_prefix:\\n filename = self.prefix\\n\\n split_ext = os.path.splitext(filename)\\n if split_ext[1] not in [\\\".h5\\\", \\\".hdf5\\\"]:\\n filename = split_ext[0] + \\\".h5\\\"\\n\\n # Load file into outcont attribute\\n self.outcont = self._load_file(filename)\\n\\n else:\\n self.prefix = os.path.splitext(self.prefix)[0]\",\n \"def SetFileName(self, *args) -> \\\"void\\\":\\n return _itkVTKPolyDataReaderPython.itkVTKPolyDataReaderMF3_SetFileName(self, *args)\",\n \"def setup(self, files):\\n if not isinstance(files, (list, tuple)):\\n raise RuntimeError(\\\"Argument must be list of files.\\\")\\n\\n self.files = files\\n\\n # Set up frequency selection.\\n if self.freq_physical:\\n basefreq = np.linspace(800.0, 400.0, 1024, endpoint=False)\\n self.freq_sel = sorted(\\n set([np.argmin(np.abs(basefreq - freq)) for freq in self.freq_physical])\\n )\\n\\n elif self.channel_range and (len(self.channel_range) <= 3):\\n self.freq_sel = slice(*self.channel_range)\\n\\n elif self.channel_index:\\n self.freq_sel = self.channel_index\\n\\n else:\\n self.freq_sel = slice(None)\",\n \"def download_files(self):\",\n \"def set_file_path_name(self):\\n self.file_path_name = self.get_file_path() + self.get_file_name()\",\n \"def processFileNames(self, fileNames):\\n inputFiles = [open(f,'r') for f in fileNames]\\n try:\\n datainput.processFiles(inputFiles)\\n finally:\\n for fp in inputFiles:\\n fp.close()\",\n \"def paths(self, paths):\\r\\n self._paths = paths\\r\\n self._extract()\",\n \"def SetFileName(self, *args) -> \\\"void\\\":\\n return _itkVTKPolyDataReaderPython.itkVTKPolyDataReaderMF2_SetFileName(self, *args)\",\n \"def make_files(self):\\n return []\",\n \"def read(self,filenames):\\n\\n if isinstance(filenames, basestring):\\n filenames = [filenames]\\n read_ok = []\\n for filename in filenames:\\n try:\\n fp = open(filename)\\n except IOError:\\n continue\\n self._read(fp)\\n fp.close()\\n read_ok.append(filename)\\n return read_ok\",\n \"def associate_files(self):\\n self.MatlabFiles = {'defaults': os.path.join(self.ParentDir,'defaults.m'),\\n 'avevel': os.path.join(self.OutDir, 'pix2avevel.mat'),\\n 'cumdef': os.path.join(self.OutDir, 'pix2cumdef.mat'),\\n 'variance': os.path.join(self.OutDir, 'vaiance.mat')}\",\n \"def _initNames(self):\\n self.outselect = os.path.join(self.workpath, 'FT1_selected'+self.suffix+'.fits')\\n self.outmktime = os.path.join(self.workpath, 'FT1_filtered'+self.suffix+'.fits')\\n self.outltcube = os.path.join(self.workpath, 'LtCube'+self.suffix+'.fits')\\n self.outbincub = os.path.join(self.workpath, 'BinCube'+self.suffix+'.fits')\\n self.outbinmap = os.path.join(self.workpath, 'CMAP'+self.suffix+'.fits')\\n self.outbinexp = os.path.join(self.workpath, 'BinExpMap'+self.suffix+'.fits')\\n self.outexpmap = os.path.join(self.workpath, 'ExpMap'+self.suffix+'.fits')\\n self.outsrcmap = os.path.join(self.workpath, 'SrcMaps'+self.suffix+'.fits')\\n self.outgtlike = os.path.join(self.workpath, 'Results'+self.suffix+'.dat')\\n self.outmodel = os.path.join(self.workpath, 'OutModel'+self.suffix+'.xml')\\n self.outapert = os.path.join(self.workpath, 'LC_ApPhoto'+self.suffix+'.fits')\\n self.outgtmod = os.path.join(self.workpath, 'GtModel'+self.suffix+'.fits')\\n self.outresid = os.path.join(self.workpath, 'Resid'+self.suffix+'.fits')\\n self.outresig = os.path.join(self.workpath, 'ResSigma'+self.suffix+'.fits')\\n self.outtsmap = os.path.join(self.workpath, 'TSMmap'+self.suffix+'.fits')\\n return\\n # self.outfind = self.dir + self.src + '_FindSrc'+self.suffix+'.txt'\",\n \"def set_paths(self, paths):\\n self.paths = paths\",\n \"def extract_files(self, *filenames):\\n for filename in filenames:\\n data = self.read_file(filename)\\n f = open(filename, 'wb')\\n f.write(data or b'')\\n f.close()\",\n \"def fixupFileNames(process):\\n if not hasattr(process.source, \\\"fileNames\\\"):\\n process.source.fileNames = cms.untracked.vstring()\\n return\",\n \"def files_set(self):\\n return UploadedFile.get_files_for(self)\",\n \"def listFiles(self):\\n pass\",\n \"def __setFileName(self,\\n fileName):\\n self.__fileName = fileName\\n return self\",\n \"def set_documents_names(cls, input_list_names: List[str]) -> None:\\n cls.documents_names = input_list_names\",\n \"def parse_files(self, filenames=\\\"\\\"):\\n if self._parsed:\\n raise Exception(\\\"Have been parsed\\\")\\n self._parsed = True\\n\\n if filenames:\\n if not isinstance(filenames, (list, tuple)):\\n filenames = self._parse_string(filenames).strip(\\\", \\\").split(\\\",\\\")\\n\\n for filename in filenames:\\n self._parse_file(filename)\\n\\n self._check_and_fix()\",\n \"def clean_files(self):\\n self.filenames.clear()\",\n \"def get_tweet_file_names(self) -> None:\\n self.list_of_files = os.listdir(self.input_file_path)\\n no_of_files = len(self.list_of_files)\\n for iterator in range(0, no_of_files):\\n self.list_of_files[iterator] = self.input_file_path + \\\"\\\\\\\\\\\" + self.list_of_files[iterator]\\n print(\\\"no of json files \\\",no_of_files)\",\n \"def set_directories(args):\\n global READS_DIR\\n READS_DIR = args.reads_dir\\n if not os.path.isdir(READS_DIR):\\n sys.exit(\\\"%s not a directory\\\" % READS_DIR)\\n READS_DIR = os.path.abspath(READS_DIR) + \\\"/\\\"\\n os.chdir(READS_DIR)\",\n \"def files(self):\\n all_files = set()\\n for label in self.filesets:\\n all_files.update(self.filesets[label])\\n return all_files\",\n \"def _read_files(self):\\n \\n for langname in self.langnames:\\n filename = f'data/word_lists/{langname}.txt'\\n with open(filename) as f:\\n index = self.langnames.index(langname)\\n lang_list = getattr(self, f'word_list{index}')\\n words = f.readlines()\\n for word in words:\\n fword = ''.join(char for char in word if char is not '\\\\n')\\n lang_list.append(fword)\\n f.close()\\n return\",\n \"def receiveFileFromDialog(self, paths):\\n self.filesList.filesStartedLoading.emit(False)\\n for p in paths:\\n self.filesList.registerFile(None, QtCore.QString(p))\\n self.filesList.filesFinishedLoading.emit(True)\",\n \"def add_files(self, paths):\\n for path in paths:\\n self.add_file(path)\",\n \"def setup(self, files):\\n if self.acqtype not in self._acqtype_reader:\\n raise ValueError(f'Specified acqtype \\\"{self.acqtype}\\\" is not supported.')\\n\\n if not isinstance(files, (list, tuple)):\\n raise ValueError(\\\"Argument must be list of files.\\\")\\n\\n self.files = files\",\n \"def get_files(self):\\n # self.folder= +str(int(time.time()))\\n if not os.path.exists(self.folder):\\n os.mkdir(self.folder)\\n while len(self.url_queue): # If we have URLs to crawl - we crawl\\n href = self.url_queue.popleft() # We grab a URL from the left of the list\\n filename = href.rsplit('/', 1)[-1]\\n print(\\\"Downloading %s to %s...\\\" % (href, filename))\\n fullname = os.path.join(self.folder, filename)\\n urlretrieve(href, fullname)\\n self.xlfnames.append(filename)\",\n \"def load_data(self):\\n for set_name in self.image_dir_path:\\n if self.verbose:\\n print('\\\\n> Loading data files for the set: ' + set_name)\\n\\n # image dir\\n image_dir = os.path.join(self.data_path, self.image_dir_path[set_name])\\n\\n # annotation file path\\n annot_filepath = os.path.join(self.data_path, self.annotation_path[set_name])\\n\\n if 'test' in set_name:\\n yield load_data_test(set_name, image_dir, annot_filepath, self.verbose)\\n else:\\n yield self.load_data_trainval(set_name, image_dir, annot_filepath)\",\n \"def _find_named_files(self):\\n for name, description in self.named_files.iteritems():\\n name = name.format(job_name=self.job_name)\\n f_path = '{}/{}'.format(self.rism3d_folder, name)\\n if os.path.isfile(f_path):\\n self.file_path_dic[description] = f_path\\n else:\\n self._not_found_error(f_path)\",\n \"def SetFilename(self, f):\\n self._filename = f\",\n \"def set_options(self, option_list):\\n self._file_name = option_list['output_file'].get_value()\",\n \"def __init__(self, files, **kwargs):\\n self.files = {name: (None, data, 'application/octet-stream', {}) for name, data in files.iteritems()}\\n for name, data in kwargs.iteritems():\\n name = name.replace('_', '-')\\n try:\\n options = self.options_by_name[name]\\n except KeyError:\\n raise ValueError('Unknown option {}'.format(name))\\n self.files[name] = (None, data, options.content_type, options.headers)\",\n \"def setStatiFile(self, filename):\\n self.statiFile = filename\",\n \"def files(self):\\r\\n all_files = set()\\r\\n for label in self.filesets:\\r\\n all_files.update(self.filesets[label])\\r\\n return all_files\",\n \"def files(self):\\r\\n all_files = set()\\r\\n for label in self.filesets:\\r\\n all_files.update(self.filesets[label])\\r\\n return all_files\",\n \"def prepare_filenames(config: Dict[str, Any]) -> Dict[str, Any]:\\n for handler_name in config[\\\"handlers\\\"].keys():\\n handler_config = config[\\\"handlers\\\"][handler_name]\\n if \\\"filename\\\" in handler_config:\\n filename = Path(handler_config[\\\"filename\\\"]).name\\n handler_config[\\\"filename\\\"] = str(LOGS_DIR.joinpath(filename))\\n return config\",\n \"def SetFileName(self, *args) -> \\\"void\\\":\\n return _itkVTKPolyDataReaderPython.itkVTKPolyDataReaderMD3_SetFileName(self, *args)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6955265","0.6887402","0.6878499","0.67892617","0.6675026","0.6572736","0.65357256","0.65231085","0.64586145","0.64167434","0.6371263","0.6240702","0.6175739","0.6168266","0.61507344","0.6141928","0.61352116","0.6123154","0.6068659","0.6062177","0.60527366","0.59976","0.599101","0.5984772","0.5980417","0.5964459","0.5948665","0.5947353","0.59333664","0.5925125","0.59190404","0.5913133","0.5907783","0.5898141","0.588922","0.5876622","0.5870405","0.5864258","0.58543247","0.5848954","0.5827403","0.58256423","0.58104616","0.57917416","0.57869333","0.57845265","0.5759612","0.5754263","0.573561","0.5722492","0.57139224","0.57032067","0.57002354","0.57000136","0.5694816","0.56882036","0.5686324","0.5684419","0.5677718","0.5675255","0.5669877","0.56649894","0.5663994","0.56555665","0.5641285","0.5625837","0.5622011","0.5621636","0.5617949","0.5617229","0.5607212","0.5606391","0.55955863","0.55931586","0.5583197","0.5580898","0.5574398","0.556907","0.55620825","0.5541948","0.5541639","0.5541297","0.55398214","0.5537948","0.5507685","0.5499076","0.5486449","0.5480128","0.54788744","0.5475625","0.54715896","0.54704374","0.54678786","0.5461657","0.5460538","0.5458359","0.5449884","0.5449884","0.5442288","0.54414624"],"string":"[\n \"0.6955265\",\n \"0.6887402\",\n \"0.6878499\",\n \"0.67892617\",\n \"0.6675026\",\n \"0.6572736\",\n \"0.65357256\",\n \"0.65231085\",\n \"0.64586145\",\n \"0.64167434\",\n \"0.6371263\",\n \"0.6240702\",\n \"0.6175739\",\n \"0.6168266\",\n \"0.61507344\",\n \"0.6141928\",\n \"0.61352116\",\n \"0.6123154\",\n \"0.6068659\",\n \"0.6062177\",\n \"0.60527366\",\n \"0.59976\",\n \"0.599101\",\n \"0.5984772\",\n \"0.5980417\",\n \"0.5964459\",\n \"0.5948665\",\n \"0.5947353\",\n \"0.59333664\",\n \"0.5925125\",\n \"0.59190404\",\n \"0.5913133\",\n \"0.5907783\",\n \"0.5898141\",\n \"0.588922\",\n \"0.5876622\",\n \"0.5870405\",\n \"0.5864258\",\n \"0.58543247\",\n \"0.5848954\",\n \"0.5827403\",\n \"0.58256423\",\n \"0.58104616\",\n \"0.57917416\",\n \"0.57869333\",\n \"0.57845265\",\n \"0.5759612\",\n \"0.5754263\",\n \"0.573561\",\n \"0.5722492\",\n \"0.57139224\",\n \"0.57032067\",\n \"0.57002354\",\n \"0.57000136\",\n \"0.5694816\",\n \"0.56882036\",\n \"0.5686324\",\n \"0.5684419\",\n \"0.5677718\",\n \"0.5675255\",\n \"0.5669877\",\n \"0.56649894\",\n \"0.5663994\",\n \"0.56555665\",\n \"0.5641285\",\n \"0.5625837\",\n \"0.5622011\",\n \"0.5621636\",\n \"0.5617949\",\n \"0.5617229\",\n \"0.5607212\",\n \"0.5606391\",\n \"0.55955863\",\n \"0.55931586\",\n \"0.5583197\",\n \"0.5580898\",\n \"0.5574398\",\n \"0.556907\",\n \"0.55620825\",\n \"0.5541948\",\n \"0.5541639\",\n \"0.5541297\",\n \"0.55398214\",\n \"0.5537948\",\n \"0.5507685\",\n \"0.5499076\",\n \"0.5486449\",\n \"0.5480128\",\n \"0.54788744\",\n \"0.5475625\",\n \"0.54715896\",\n \"0.54704374\",\n \"0.54678786\",\n \"0.5461657\",\n \"0.5460538\",\n \"0.5458359\",\n \"0.5449884\",\n \"0.5449884\",\n \"0.5442288\",\n \"0.54414624\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72363704"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94981,"cells":{"query":{"kind":"string","value":"Set a flag indicating whether the image should be flipped vertically"},"document":{"kind":"string","value":"def setVerticalFlip(self, flag):\n\t\tif self.ext.lower() in [\"png\", \"jpg\", \"jpeg\"]:\n\t\t\tself.flipVertically = not flag\n\t\telse:\n\t\t\tself.flipVertically = flag"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def flip_vertical(img):\r\n #reading image\r\n im = Image.open(\"filename\")\r\n\r\n #flipping image vertically\r\n newimg = im.transpose(PIL.Image.FLIP_TOP_BOTTOM)\r\n return img","def flip_image_vertical(image):\n return cv.flip(image, 1)","def flip_image(img, vert=True):\n if vert:\n return img.transpose(Image.FLIP_TOP_BOTTOM)\n else:\n return img.transpose(Image.FLIP_LEFT_RIGHT)","def vflip(img):\n #if not _is_pil_image(img):\n # raise TypeError('img should be PIL Image. Got {}'.format(type(img)))\n\n return img.transpose(Image.FLIP_TOP_BOTTOM)","def flip(self):\n \n if self.faceup:\n self.faceup = False\n else:\n self.faceup = True","def setHorizontalFlip(self, flag):\n\t\tself.flipHorizontally = flag","def flip(img, boolean=True):\n return pg.transform.flip(img, boolean, False)","def flip_vertical(original_image: Image) -> Image :\r\n \r\n new_image = copy(original_image)\r\n \r\n pixel_width = get_width(original_image)\r\n pixel_height = get_height(original_image) \r\n\r\n \r\n for x in range(pixel_width) :\r\n for y in range(pixel_height) :\r\n original_vertical_pixel = get_color(original_image, x, y)\r\n opposite_vertical_pixel = pixel_height - 1 - y\r\n set_color(new_image, x, opposite_vertical_pixel, original_vertical_pixel)\r\n \r\n return new_image","def flip(self):","def flip_vertical(image: Image) -> Image:\r\n flipped_image = copy(image)\r\n middle_pixel = get_width(flipped_image) // 2\r\n width = get_width(flipped_image)\r\n height = get_height(flipped_image)\r\n \r\n for x in range(middle_pixel):\r\n for y in range(height):\r\n r,g,b = get_color(image,x,y)\r\n new_r, new_g, new_b = get_color(image, abs(width-x) - 1, y)\r\n set_color(flipped_image,x,y,create_color(new_r,new_g,new_b))\r\n set_color(flipped_image,width-x-1,y,create_color(r,g,b))\r\n \r\n return flipped_image","def flip(self, xbool, ybool):\n self._surf = pygame.transform.flip(self._surf, xbool, ybool).convert_alpha()","def flip(self, mode='h'):\n # TODO: Implement the flip function. Remember to record the boolean values is_horizontal_flip and\n # is_vertical_flip.\n if mode == 'h':\n self.is_horizontal_flip = True\n self.x = np.flipud(self.x)\n elif mode == 'v':\n self.is_vertical_flip = True\n self.x = np.fliplr(self.x)\n else:\n self.is_vertical_flip = True\n self.is_horizontal_flip = True\n self.x = np.fliplr(self.x)\n self.x = np.flipud(self.x)\n # raise NotImplementedError\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################","def flip(self, bev_direction: str = 'horizontal') -> None:\n pass","def flip_faceup(self):\r\n self.faceup = True","def td_flip(self):\n self.cw_rotate()\n self.cw_rotate()\n self.lr_flip()\n self.find_edges()","def flip_vertical(image: Image) -> Image:\r\n flipped_image = copy(image)\r\n middle_pixel = get_width(flipped_image) // 2\r\n width = get_width(flipped_image)\r\n height = get_height(flipped_image)\r\n\r\n for x in range(middle_pixel):\r\n for y in range(height):\r\n r, g, b = get_color(image, x, y)\r\n new_r, new_g, new_b = get_color(image, abs(width - x) - 1, y)\r\n set_color(flipped_image, x, y, create_color(new_r, new_g, new_b))\r\n set_color(flipped_image, width - x - 1, y, create_color(r, g, b))\r\n\r\n return flipped_image","def test_flip_vertical() -> None:\n original = create_image(3, 2)\n set_color(original, 0, 0, create_color(0, 0, 0))\n set_color(original, 1, 0, create_color(90, 90, 90))\n set_color(original, 2, 0, create_color(255, 255, 255))\n set_color(original, 0, 1, create_color(10, 10, 10))\n set_color(original, 1, 1, create_color(0, 0, 0))\n set_color(original, 2, 1, create_color(90, 90, 90))\n \n expected = create_image(3, 2)\n set_color(expected, 0, 0, create_color(10, 10, 10))\n set_color(expected, 1, 0, create_color(0, 0, 0))\n set_color(expected, 2, 0, create_color(90, 90, 90))\n set_color(expected, 0, 1, create_color(0, 0, 0))\n set_color(expected, 1, 1, create_color(90, 90, 90))\n set_color(expected, 2, 1, create_color(255, 255, 255))\n \n flipped_vertical = flip_vertical(original)\n \n for x, y, col in flipped_vertical: # tests each colour of each pixel of the filtered sample image and compares it to the expected image\n check_equal('Checking pixel @(' + str(x) + ', ' + str(y) + ')', col, get_color(expected, x, y))","def set_flip(self, val):\n self.flip = val","def __flip(img, flip, flip_type=Image.FLIP_LEFT_RIGHT):\n if flip:\n return img.transpose(flip_type)\n return img","def set_flipped(self, x, y):\n self.pieces[x + (y * self.width)].set_flipped()","def flip(self):\n if self.is_face_up:\n arcade.load_texture(self.back_file)\n self.is_face_up = False\n else:\n arcade.load_texture(self.face_file)\n self.is_face_up = True","def flip(self, horizontally):\n\t\tself.currentPixbuf = self.currentPixbuf.flip(horizontally)\n\t\tself.scaleCache[1] = 0\n\t\tgc.collect()","def flip_augmentation():\n return lambda image: ImageOps.flip(image)","def flipNormals(self):\n self.flip = not self.flip","def mirrorImage(self):\n\n im = Image.open(self.ActivePhoto)\n out = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\n out.save(self.ActivePhoto)\n self.photo.setPixmap(QtGui.QPixmap(self.ActivePhoto))\n print (\"Flipped image\")","def flip(self):\n self.width, self.height = self.height, self.width","def flip(img, code=0):\n\treturn cv2.flip(img, flipCode=code)","def vflip(img):\n if not _is_numpy(img):\n raise TypeError('img should be Numpy Image. Got {}'.format(type(img)))\n\n return np.flipud(img)","def flip(self, x: bool, y: bool) -> 'BaseImage':\n assert isinstance(x, bool)\n assert isinstance(y, bool)\n assert (x or y), 'at least one axis should be True'\n self._surface = pygame.transform.flip(self._surface, x, y)\n return self","def flip_h(image, gt):\n result_im = cv2.flip(image, 1)\n result_gt = cv2.flip(gt, 1)\n\n return result_im, result_gt","def vflip(img, data_format='CHW'):\n _assert_image_tensor(img, data_format)\n\n h_axis = _get_image_h_axis(data_format)\n\n return img.flip(axis=[h_axis])","def flip_image(image):\n return cv2.flip(image, flipCode=1)","def img_add_flip(arr, flip_horiz = True, flip_vert = False):\r\n assert len(arr.shape) == 3, \"'arr' input array must be three dimensional\"\r\n arr_copy = arr.copy()\r\n if flip_horiz:\r\n arr_copy = np.fliplr(arr_copy)\r\n if flip_vert:\r\n arr_copy = np.flipud(arr_copy)\r\n return arr_copy","def flip(self, horizontal):\n try:\n self._is_transformable()\n horizontal = get_int(horizontal)\n except NotTransformable as e:\n self._app[\"statusbar\"].message(str(e) + \" flip\", \"error\")\n return\n except StringConversionError as e:\n self._app[\"statusbar\"].message(str(e), \"error\")\n return\n images = self.get_images(\"Flipped\")\n # Apply changes\n for fil in images:\n if fil not in self._changes:\n self._changes[fil] = [0, 0, 0]\n if horizontal:\n self._changes[fil][1] = \\\n (self._changes[fil][1] + 1) % 2\n else:\n self._changes[fil][2] = \\\n (self._changes[fil][2] + 1) % 2\n # Flip the image shown\n if self._app.get_path() in images:\n self.emit(\"changed\", \"flip\", horizontal)\n # Reload thumbnails of flipped images immediately\n if self._app[\"thumbnail\"].toggled:\n self.apply()","def collate_fn_flip(self, batch):\n FT = torch.FloatTensor\n img, uvd_gt = zip(*batch)\n flip = random.randint(1, 10000)%2\n # Do flipping\n # 0 = left, 1 = right\n hand_side = 1\n if flip:\n hand_side = 0 \n\n new_img = []\n new_uvd = []\n for i, u in batch:\n if flip:\n i = i.transpose(Image.FLIP_LEFT_RIGHT)\n u[:, 0] = 0.999 - u[:, 0]\n i = np.asarray(i)\n i = i/255.0\n i = IMG.imgshape2torch(i)\n new_img.append(i)\n new_uvd.append(u)\n \n new_img = FT(new_img)\n new_uvd = FT(new_uvd)\n return new_img, new_uvd, hand_side","def flip(self, row: int, col: int) -> None:\n self.state[row, col] = not self.state[row, col]","def flip_image(image):\n\n return cv2.flip(image, 1)","def test_random_vertical_flip(dummy_input):\n # Test the 2D image: H, W, C\n image, label = dummy_input(image_size=(512, 512, 3),\n label_size=(512, 512, 1))\n transform = RandomVerticalFlip(prob=1)\n _image, _label = transform(image, label)\n _image, _label = transform(_image, _label)\n assert (image == _image).all()\n assert (label == _label).all()\n \n # Test the 3D image: H, W, D, C\n image, label = dummy_input(image_size=(512, 512, 20, 3),\n label_size=(512, 512, 20, 1))\n transform = RandomVerticalFlip(prob=1)\n _image, _label = transform(image, label)\n _image, _label = transform(_image, _label)\n assert (image == _image).all()\n assert (label == _label).all()","def vflip(img):\n if not _is_numpy_image(img):\n raise TypeError('img should be nparray Image. Got {}'.format(type(img)))\n\n return cv2.flip(img, 0)","def flip_image(image, label):\n # Flip the image\n cv2.flip(image, 1, image)\n\n # Flip the label\n label[1] = image.shape[1] - label[1]","def set_flip(self, flipconv):\n if flipconv is None:\n flipconv = 'astro' # default\n if flipconv == 'astro': self._flip = -1\n elif flipconv == 'geo': self._flip = 1\n else: raise ValueError(\"flipconv must be 'astro', 'geo' or None for default.\")","def set_flipout(flipout):\n if isinstance(flipout, bool):\n __SETTINGS__._FLIPOUT = flipout\n else:\n raise TypeError('flipout must be True or False')","def vflip(self):\n for y in range(0, self.height // 2):\n for x in range(0, self.width):\n self._chars[x][y], self._chars[x][self.height - 1 - y] = self._chars[x][self.height - 1 - y], self._chars[x][y]\n self._fginfo[x][y], self._fginfo[x][self.height - 1 - y] = self._fginfo[x][self.height - 1 - y], self._fginfo[x][y]\n self._bginfo[x][y], self._bginfo[x][self.height - 1 - y] = self._bginfo[x][self.height - 1 - y], self._bginfo[x][y]\n self._strDirty = True","def mirror(image):\n\n return cv2.flip(image, 1)","def saveflip(image, fname, outpath, axis='x', preserve_name=False):\n if not preserve_name:\n fpath = genSavePath(outpath, fname, modstring=f\"mirror_{axis}\")\n else:\n fpath = genSavePath(outpath, fname)\n im = copy(image)\n if axis == 'x':\n im = im.transpose(Image.FLIP_LEFT_RIGHT)\n elif axis == 'y':\n im = im.transpose(Image.FLIP_TOP_BOTTOM)\n else:\n raise Exception('No valid axis procvided for flipping: {} - received value: {}'.format(fname, axis))\n try:\n im.save(fpath, subsample=\"keep\", qtables=image.quantization, optimize=True)\n\n except IOError as m:\n print( \"Flipped({}) image creation failed for: {}. \\nReason:{}\".format(axis,fname,m))","def _augment(img):\r\n return flip(img, axis=2)","def flip_horizontal(img):\r\n #reading image\r\n im = Image.open(\"filename\")\r\n\r\n #flipping image horizontally\r\n newimg = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\r\n \r\n return img","def flip_image(image_path, saved_location):\n image_obj = Image.open(image_path)\n rotated_image = image_obj.transpose(Image.FLIP_LEFT_RIGHT)\n rotated_image.save(saved_location)","def flip_image(image, direction):\n prevShape = image.shape\n image, reshaped = reshape_to_cv_format(image, False)\n image = cv.flip(image, direction)\n if reshaped: \n image = image.reshape(prevShape)\n return image","def setFlag(self):\n if self.inPlay and not self.shown:\n self.flag = not(self.flag)\n image_index = 11 if self.flag else 10\n self.configure(image = Tile.images[image_index])\n return 1 if self.flag else -1\n return 0","def flip_image_horizontal(image):\n return cv.flip(image, 0)","def flip(self, xflip=True, yflip=False):\n self.drawer.flush()\n img = self.img\n if xflip: img = img.transpose(PIL.Image.FLIP_LEFT_RIGHT)\n if yflip: img = img.transpose(PIL.Image.FLIP_TOP_BOTTOM)\n self.img = img\n self.update_drawer_img()\n return self","def _augment(img):\n return flip(img, axis=2)","def flip(self):\n self.align = self._left if self.align == self._right else self._right\n self.group.layout_all()","def flip_rotate(img):\r\n\r\n choice = int(8*np.random.rand())\r\n \r\n if choice == 0:\r\n return img\r\n if choice == 1:\r\n return np.rot90(img, 1)\r\n if choice == 2:\r\n return np.rot90(img, 2)\r\n if choice == 3:\r\n return np.rot90(img, 3)\r\n if choice == 4:\r\n return np.flip(img, 0)\r\n if choice == 5:\r\n return np.flip(img, 1)\r\n if choice == 6:\r\n return np.flip(np.rot90(img, 1), 0)\r\n if choice == 7:\r\n return np.flip(np.rot90(img, 1), 1)","def check_flip(origin_imgs, result_imgs, flip_type):\n n, _, _, _ = np.shape(origin_imgs)\n if flip_type == 'horizontal':\n for i in range(n):\n if np.any(result_imgs[i] != np.fliplr(origin_imgs[i])):\n return False\n else:\n # yapf: disable\n for i in range(n):\n if np.any(result_imgs[i] != np.transpose(np.fliplr(np.transpose(origin_imgs[i], (1, 0, 2))), (1, 0, 2))): # noqa:E501\n return False\n # yapf: enable\n return True","def reversible(self) -> bool:\n xy_row = np.column_stack(\n (\n np.linspace(\n -self.imgsz[0] / (2 * self.f[0]),\n self.imgsz[0] / (2 * self.f[0]),\n int(self.imgsz[0]),\n ),\n np.zeros(int(self.imgsz[0])),\n )\n )\n dxy = self._distort(xy_row)\n continuous_row = np.all(dxy[1:, 0] >= dxy[:-1, 0])\n xy_col = np.column_stack(\n (\n np.zeros(int(self.imgsz[1])),\n np.linspace(\n -self.imgsz[1] / (2 * self.f[1]),\n self.imgsz[1] / (2 * self.f[1]),\n int(self.imgsz[1]),\n ),\n )\n )\n dxy = self._distort(xy_col)\n continuous_col = np.all(dxy[1:, 1] >= dxy[:-1, 1])\n return continuous_row and continuous_col","def on_IV_mode_toggled(self, checked):\n # TODO: not implemented yet\n if checked:\n self.vimode = 0\n qmdz_const.VI_MODE = 0\n self.sample_id.setText(\"IV_test\")\n self.VI_MPL.clear_curve()\n self.VI_MPL.set_iv_mode()","def readout_flipped(self, iamp):\n flipped = ct.c_int()\n self.lib.IsReadoutFlippedByAmplifier(ct.c_int(iamp),\n ct.pointer(flipped))\n return bool(flipped.value)","def fl_flip_yorigin():\n _fl_flip_yorigin = library.cfuncproto(\n library.load_so_libforms(), \"fl_flip_yorigin\",\\\n None, [],\\\n \"\"\"void fl_flip_yorigin()\"\"\")\n _fl_flip_yorigin()","def flip_frame(frame, flip_code):\n return cv.flip(frame, flip_code)","def flip(self) -> int:\n self.flags = ~(self.flags)\n return self.flags","def set_flip_board(self, new_value: bool) -> None:\n self._flip_board = new_value","def _flip_y(self, zoom, row):\n\n if row is None or zoom is None:\n raise TypeError(\"zoom and row cannot be null\")\n\n return (2 ** zoom) - 1 - row","def random_flip(image ):\n if random.randint(0,1):\n image = flipud(image) # vertical flip\n if random.randint(0,1):\n image = fliplr(image) # horizontal flip\n return image","def fliplr(img):\n inv_idx = torch.arange(img.size(3) - 1, -1, -1).long() # N x C x H x W\n img_flip = img.index_select(3, inv_idx)\n\n return img_flip","def invert(self, img):\n return self.inverse()(img)","def flip(h):\n return np.flip(h)","def flip(h):\n return np.flip(h)","def collate_fn_no_flip(self, batch):\n FT = torch.FloatTensor\n img, uvd_gt = zip(*batch)\n\n new_img = []\n new_uvd = []\n for i, u in batch:\n if self.pred_img_side == 'left':\n i = i.transpose(Image.FLIP_LEFT_RIGHT)\n u[:, 0] = 0.999 - u[:, 0]\n i = np.asarray(i)\n i = i/255.0\n i = IMG.imgshape2torch(i)\n new_img.append(i)\n new_uvd.append(u)\n \n new_img = FT(new_img)\n new_uvd = FT(new_uvd)\n return new_img, new_uvd","def invert(self, val):\n self._invert = val\n if val:\n self.write_cmd(self.CMD_SET_DISP_REVERSE)\n else:\n self.write_cmd(self.CMD_SET_DISP_NORMAL)","def random_vertical_filp(self, img, p = 0.5):\n if self.decision(p):\n img = cv2.flip(img, 0)\n return img","def __splitOrientation(self, checked):\n if checked:\n self.setSplitOrientation(Qt.Horizontal)\n self.splitViewAct.setIcon(\n UI.PixmapCache.getIcon(\"splitHorizontal.png\"))\n self.splitRemoveAct.setIcon(\n UI.PixmapCache.getIcon(\"remsplitHorizontal.png\"))\n self.newDocumentSplitViewAct.setIcon(\n UI.PixmapCache.getIcon(\"splitHorizontal.png\"))\n else:\n self.setSplitOrientation(Qt.Vertical)\n self.splitViewAct.setIcon(\n UI.PixmapCache.getIcon(\"splitVertical.png\"))\n self.splitRemoveAct.setIcon(\n UI.PixmapCache.getIcon(\"remsplitVertical.png\"))\n self.newDocumentSplitViewAct.setIcon(\n UI.PixmapCache.getIcon(\"splitVertical.png\"))\n Preferences.setUI(\"SplitOrientationVertical\", checked)","def transpose(self, method):\r\n w, h = self.size\r\n if method == FLIP_LEFT_RIGHT:\r\n _im = cv2.flip(self._instance, 1)\r\n elif method == FLIP_TOP_BOTTOM:\r\n _im = cv2.flip(self._instance, 0)\r\n elif method == ROTATE_90:\r\n _im = self.rotate_bound(270)\r\n x = self.size[0]//2-self.size[1]//2\r\n box = (0, x, self.size[0], x+self.size[1])\r\n _im = self.crop(box, _im)\r\n elif method == ROTATE_180:\r\n _im = self.rotate(180, self._instance)\r\n elif method == ROTATE_270:\r\n _im = self.rotate_bound(90)\r\n x = self.size[0]//2-self.size[1]//2\r\n box = (0, x, self.size[0], x+self.size[1])\r\n _im = self.crop(box, _im)\r\n if isinstance(_im, Image):\r\n return _im\r\n elif isinstance(_im, np.ndarray):\r\n return Image(_im)","def orient(self,Y):\r\n self.orientation[Y]+=1\r\n if self.orientation[Y]>3:\r\n self.orientation[Y]=0\r\n if self.orientation[Y]<0:\r\n self.orientation[Y]=3\r\n self.can.delete(self.image_bateau[Y])\r\n self.image_bateau[Y]=self.create_image(self.img[self.orientation[Y]][Y],0,0)\r\n self.affichage(Y)","def flip_axes(input_file, flipx=True, flipy=True, flipz=False,\n use_matrix=False, use_header=True):\n import os\n import numpy as np\n import nibabel as nb\n\n # Load image volume\n img = nb.load(input_file)\n dat = img.get_data()\n if use_matrix:\n mat = img.get_affine()\n if use_header:\n hdr = img.get_header()\n lenx, leny, lenz = np.shape(dat)\n dat_new = np.zeros((lenx, leny, lenz))\n\n # Flip x\n if flipx:\n for x in range(lenx):\n dat_new[lenx-1-x,:,:] = dat[x,:,:]\n\n # Flip y\n if flipy:\n for y in range(leny):\n dat_new[:,leny-1-y,:] = dat[:,y,:]\n\n # Flip z\n if flipz:\n for z in range(lenz):\n dat_new[:,:,lenz-1-z] = dat[:,:,z]\n\n # Save output\n out_file = 'reorient_' + os.path.basename(input_file)\n if use_matrix:\n if use_header:\n img = nb.Nifti1Image(dat_new, mat, hdr)\n else:\n img = nb.Nifti1Image(dat_new, mat)\n elif use_header:\n img = nb.Nifti1Image(dat_new, np.eye(4,4), hdr)\n else:\n img = nb.Nifti1Image(dat_new, np.eye(4,4))\n\n img.to_filename(out_file)\n\n return out_file","def flip(self, bev_direction='horizontal', points=None):\n assert bev_direction in ('horizontal', 'vertical')\n if bev_direction == 'horizontal':\n self.tensor[:, 0::7] = -self.tensor[:, 0::7]\n if self.with_yaw:\n self.tensor[:, 6] = -self.tensor[:, 6] + np.pi\n elif bev_direction == 'vertical':\n self.tensor[:, 2::7] = -self.tensor[:, 2::7]\n if self.with_yaw:\n self.tensor[:, 6] = -self.tensor[:, 6]\n\n if points is not None:\n assert isinstance(points, (torch.Tensor, np.ndarray, BasePoints))\n if isinstance(points, (torch.Tensor, np.ndarray)):\n if bev_direction == 'horizontal':\n points[:, 0] = -points[:, 0]\n elif bev_direction == 'vertical':\n points[:, 2] = -points[:, 2]\n elif isinstance(points, BasePoints):\n points.flip(bev_direction)\n return points","def horizontal_flip() -> Callable:\n return lambda img: TF.hflip(img)","def flip_boxes_vertically(boxes):\n # Flip boxes vertically\n ymin, xmin, ymax, xmax = tf.split(value=boxes, num_or_size_splits=4, axis=1)\n flipped_ymin = tf.subtract(1.0, ymax)\n flipped_ymax = tf.subtract(1.0, ymin)\n flipped_boxes = tf.concat([flipped_ymin, xmin, flipped_ymax, xmax], axis=1)\n return flipped_boxes","def rotateYRight(self):\n MV = self.MV\n MV[:3, 0] = 0, 1, 0 # 1st col is right vector, make it point along y axis\n # set middle middle and middle right values to zero:\n MV[1, 1] = 0\n MV[1, 2] = 0\n a = MV[0, 1] # grab top middle value\n b = np.sqrt(1 - a**2) # calc new complementary value to get normalized vectors\n if MV[2, 1] < 0:\n b = -b # keep b -ve, reduce jumping around of axes\n MV[2, 1] = b\n MV[0, 2] = b\n MV[2, 2] = -a # needs to be -ve of MV[0, 1]\n self.MV = MV","def rotateYRight(self):\n MV = self.MV\n MV[:3, 0] = 0, 1, 0 # 1st col is right vector, make it point along y axis\n # set middle middle and middle right values to zero:\n MV[1, 1] = 0\n MV[1, 2] = 0\n a = MV[0, 1] # grab top middle value\n b = np.sqrt(1 - a**2) # calc new complementary value to get normalized vectors\n if MV[2, 1] < 0:\n b = -b # keep b -ve, reduce jumping around of axes\n MV[2, 1] = b\n MV[0, 2] = b\n MV[2, 2] = -a # needs to be -ve of MV[0, 1]\n self.MV = MV","def flip(self, axes=None, inplace=False, i=False):\n d = _inplace_enabled_define_and_cleanup(self)\n super(DimensionCoordinate, d).flip(axes=axes, inplace=True)\n\n direction = d._custom.get(\"direction\")\n if direction is not None:\n d._custom[\"direction\"] = not direction\n\n return d","def translate_image_vertical(image, translationFactor):\n\n # create vertical translation matrix\n tm = np.float32([[1, 0, 0],\n [0, 1, translationFactor]])\n return translate_image(image, tm)","def setInverted(self, state=True):\n self.__inverted = state","def horizontal_flip(img, steering_angle):\n flipped = cv2.flip(img, 1) # positive (>0) flip code means flipping about y-axis\n steering_angle = steering_angle * -1 # change sign of steering angle to account for flip\n return flipped, steering_angle","def _rotate(self):\n \r\n if self.clr == 1: # (default rotation) \r\n # o o o o \r\n # o x x o x o o x\r\n # o o o o\r\n _colOffsets = [[-1,-1, 0, 0], [-1, 0, 0, 1], [ 1, 1, 0, 0], [ 1, 0, 0,-1]] #\r\n _rowOffsets = [[ 1, 0, 0,-1], [-1,-1, 0, 0], [-1, 0, 0, 1], [ 1, 1, 0, 0]] #\r\n elif self.clr == 2:\r\n # o o o o \r\n # o x o x x o x o\r\n # o o o o\r\n _colOffsets = [[-1,-1, 0, 0], [ 1, 0, 0,-1], [ 1, 1, 0, 0], [-1, 0, 0, 1]] #\r\n _rowOffsets = [[-1, 0, 0, 1], [-1,-1, 0, 0], [ 1, 0, 0,-1], [ 1, 1, 0, 0]] #\n \r\n elif self.clr == 3: # \r\n # o o o o \r\n # x o x o x o x o\r\n # o o o o\n \r\n _colOffsets = [[-1, 0, 0, 0], [-1,-1, 0, 1], [ 1, 0, 0, 0], [ 1, 1, 0,-1]] #\r\n _rowOffsets = [[ 1, 1, 0,-1], [-1, 0, 0, 0], [-1,-1, 0, 1], [ 1, 0, 0, 0]] #\n \r\n elif self.clr == 4:\r\n # o o o o \r\n # x o x o x o x o\r\n # o o o o\r\n _colOffsets = [[-1, 0, 0, 0], [1, 1, 0, -1], [1, 0, 0,0], [-1, -1, 0,1]]\n _rowOffsets = [[-1,-1, 0, 1], [-1,0, 0, 0], [1,1, 0,-1], [1,0, 0, 0]]\n \r\n elif self.clr == 5: # o o\r\n # o x \r\n # x o x o o o o o x o\r\n # o o \r\n _colOffsets = [[ 0, 0, 0, 0], [ 2, 1, 0,-1], [ 0, 0, 0, 0], [-2,-1, 0, 1]] #\r\n _rowOffsets = [[-2,-1, 0, 1], [ 0, 0, 0, 0], [ 2, 1, 0,-1], [ 0, 0, 0, 0]] #\r\n elif self.clr == 6: #\r\n # o o o \r\n # o x o x o x o o x o\r\n # o o o \r\n _colOffsets = [[ 0,-1, 0, 0], [-1, 0, 0, 1], [ 0, 1, 0, 0], [ 1, 0, 0,-1]] #\r\n _rowOffsets = [[ 1, 0, 0,-1], [ 0,-1, 0, 0], [-1, 0, 0, 1], [ 0, 1, 0, 0]] #\r\n elif self.clr == 7: # \r\n # o o o o o o o o\r\n # o x o x o x o x\r\n # \r\n _colOffsets = [[-1,-1, 0, 0], [-1,-1, 0, 0], [-1,-1, 0, 0], [-1,-1, 0, 0]] #@@\r\n _rowOffsets = [[ 0,-1, 0,-1], [ 0,-1, 0,-1], [ 0,-1, 0,-1], [ 0,-1, 0,-1]] #@@\n \r\n self._colOffsets = _colOffsets[self._rot] #@@\r\n self._rowOffsets = _rowOffsets[self._rot] #@@\r\n self._update() #@@\r","def flip_tile(self, tile, flag=False):\n selected_tile = self.stack[tile]\n\n if flag == True:\n if self.flags_remaining == 0:\n raise ValueError(\"No flags left\")\n else:\n selected_tile['flag']=True\n self.flags_remaining -= 1\n\n else:\n if selected_tile['flag'] == True:\n selected_tile['flag'] == False\n self.flags_remaining += 1\n\n else:\n self.stack[tile]['flip'] = True\n self.tiles_remaining -= 1\n if selected_tile['value'] == 'bomb':\n self.end_game()\n elif selected_tile['value'] == 0:\n self.blank_tile_cascade(tile)\n self.check_win()","def sym_right_img(img):\n img = img.transpose(Image.FLIP_LEFT_RIGHT)\n return sym_left_img(img)","def __flip(self, image, landmarks, run_prob=0.5):\n if np.random.rand() < run_prob:\n return image, landmarks\n image = np.fliplr(image)\n landmarks[:, 0] = image.shape[1] - landmarks[:, 0]\n landmarks = LandmarkHelper.flip(landmarks, landmarks.shape[0])\n return image, landmarks","def random_flip(self, image, label, horizontal=False):\n\n flip = 1\n rand_float = uniform(0, 1)\n\n if horizontal:\n # 1 == vertical flip\n # 0 == horizontal flip\n flip = randint(0, 1)\n\n if rand_float > 0.5:\n image = cv2.flip(image, flip)\n label = cv2.flip(label, flip)\n\n return image, label","def mirror(img):\n return img[:, ::-1]","def flip(self, p):\n return -p","def flip(imgs):\n x = random.choice([-1, 0, 1, 2])\n if x == 2:\n return imgs\n else:\n return [cv2.flip(img, x) for img in imgs]","def flip(tensor, axis=None):\n raise NotImplementedError","def __update_col_facedown(self, col):\n all_is_facedown = True\n # Loop all card in column\n for card in self.solitaire[col]:\n # If no card is represented\n if card == 0:\n break\n # If at least 1 card is faceup we return from method\n if not card.is_facedown:\n all_is_facedown = False\n return\n # If all card is facedown, we can flip and reviel a new card\n # so we have one less card facing down in that column\n if all_is_facedown:\n if self.col_facedown[col] > 0:\n print(f\"Vend kort i kolonne {col}\")\n self.col_facedown[col] -= 1","def flipAndInvertImage2(self, A: List[List[int]]) -> List[List[int]]:\n def invert(x):\n if x:\n return 0\n else:\n return 1\n\n for row in A:\n left, right = 0, len(row)-1\n while left <= right:\n row[left], row[right] = invert(row[right]), invert(row[left])\n left += 1\n right -= 1\n\n return A","def evert(self):\n for e in self.edges:\n self.invert()\n for f in self.faces:\n f.invert()","def convert_flip(g, op, block):\n\n x = g.get_node(op.input(\"X\")[0])\n axis = op.attr(\"axis\")\n\n for i, ax in enumerate(axis):\n if i == 0:\n out = _op.reverse(x, ax)\n else:\n out = _op.reverse(out, ax)\n\n g.add_node(op.output(\"Out\")[0], out)","def lr_flip(self):\n for g in self.grid:\n g.reverse()","def set_invert_display(enable):\n if enable:\n send_command(0xA7)\n else:\n send_command(0xA6)"],"string":"[\n \"def flip_vertical(img):\\r\\n #reading image\\r\\n im = Image.open(\\\"filename\\\")\\r\\n\\r\\n #flipping image vertically\\r\\n newimg = im.transpose(PIL.Image.FLIP_TOP_BOTTOM)\\r\\n return img\",\n \"def flip_image_vertical(image):\\n return cv.flip(image, 1)\",\n \"def flip_image(img, vert=True):\\n if vert:\\n return img.transpose(Image.FLIP_TOP_BOTTOM)\\n else:\\n return img.transpose(Image.FLIP_LEFT_RIGHT)\",\n \"def vflip(img):\\n #if not _is_pil_image(img):\\n # raise TypeError('img should be PIL Image. Got {}'.format(type(img)))\\n\\n return img.transpose(Image.FLIP_TOP_BOTTOM)\",\n \"def flip(self):\\n \\n if self.faceup:\\n self.faceup = False\\n else:\\n self.faceup = True\",\n \"def setHorizontalFlip(self, flag):\\n\\t\\tself.flipHorizontally = flag\",\n \"def flip(img, boolean=True):\\n return pg.transform.flip(img, boolean, False)\",\n \"def flip_vertical(original_image: Image) -> Image :\\r\\n \\r\\n new_image = copy(original_image)\\r\\n \\r\\n pixel_width = get_width(original_image)\\r\\n pixel_height = get_height(original_image) \\r\\n\\r\\n \\r\\n for x in range(pixel_width) :\\r\\n for y in range(pixel_height) :\\r\\n original_vertical_pixel = get_color(original_image, x, y)\\r\\n opposite_vertical_pixel = pixel_height - 1 - y\\r\\n set_color(new_image, x, opposite_vertical_pixel, original_vertical_pixel)\\r\\n \\r\\n return new_image\",\n \"def flip(self):\",\n \"def flip_vertical(image: Image) -> Image:\\r\\n flipped_image = copy(image)\\r\\n middle_pixel = get_width(flipped_image) // 2\\r\\n width = get_width(flipped_image)\\r\\n height = get_height(flipped_image)\\r\\n \\r\\n for x in range(middle_pixel):\\r\\n for y in range(height):\\r\\n r,g,b = get_color(image,x,y)\\r\\n new_r, new_g, new_b = get_color(image, abs(width-x) - 1, y)\\r\\n set_color(flipped_image,x,y,create_color(new_r,new_g,new_b))\\r\\n set_color(flipped_image,width-x-1,y,create_color(r,g,b))\\r\\n \\r\\n return flipped_image\",\n \"def flip(self, xbool, ybool):\\n self._surf = pygame.transform.flip(self._surf, xbool, ybool).convert_alpha()\",\n \"def flip(self, mode='h'):\\n # TODO: Implement the flip function. Remember to record the boolean values is_horizontal_flip and\\n # is_vertical_flip.\\n if mode == 'h':\\n self.is_horizontal_flip = True\\n self.x = np.flipud(self.x)\\n elif mode == 'v':\\n self.is_vertical_flip = True\\n self.x = np.fliplr(self.x)\\n else:\\n self.is_vertical_flip = True\\n self.is_horizontal_flip = True\\n self.x = np.fliplr(self.x)\\n self.x = np.flipud(self.x)\\n # raise NotImplementedError\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\",\n \"def flip(self, bev_direction: str = 'horizontal') -> None:\\n pass\",\n \"def flip_faceup(self):\\r\\n self.faceup = True\",\n \"def td_flip(self):\\n self.cw_rotate()\\n self.cw_rotate()\\n self.lr_flip()\\n self.find_edges()\",\n \"def flip_vertical(image: Image) -> Image:\\r\\n flipped_image = copy(image)\\r\\n middle_pixel = get_width(flipped_image) // 2\\r\\n width = get_width(flipped_image)\\r\\n height = get_height(flipped_image)\\r\\n\\r\\n for x in range(middle_pixel):\\r\\n for y in range(height):\\r\\n r, g, b = get_color(image, x, y)\\r\\n new_r, new_g, new_b = get_color(image, abs(width - x) - 1, y)\\r\\n set_color(flipped_image, x, y, create_color(new_r, new_g, new_b))\\r\\n set_color(flipped_image, width - x - 1, y, create_color(r, g, b))\\r\\n\\r\\n return flipped_image\",\n \"def test_flip_vertical() -> None:\\n original = create_image(3, 2)\\n set_color(original, 0, 0, create_color(0, 0, 0))\\n set_color(original, 1, 0, create_color(90, 90, 90))\\n set_color(original, 2, 0, create_color(255, 255, 255))\\n set_color(original, 0, 1, create_color(10, 10, 10))\\n set_color(original, 1, 1, create_color(0, 0, 0))\\n set_color(original, 2, 1, create_color(90, 90, 90))\\n \\n expected = create_image(3, 2)\\n set_color(expected, 0, 0, create_color(10, 10, 10))\\n set_color(expected, 1, 0, create_color(0, 0, 0))\\n set_color(expected, 2, 0, create_color(90, 90, 90))\\n set_color(expected, 0, 1, create_color(0, 0, 0))\\n set_color(expected, 1, 1, create_color(90, 90, 90))\\n set_color(expected, 2, 1, create_color(255, 255, 255))\\n \\n flipped_vertical = flip_vertical(original)\\n \\n for x, y, col in flipped_vertical: # tests each colour of each pixel of the filtered sample image and compares it to the expected image\\n check_equal('Checking pixel @(' + str(x) + ', ' + str(y) + ')', col, get_color(expected, x, y))\",\n \"def set_flip(self, val):\\n self.flip = val\",\n \"def __flip(img, flip, flip_type=Image.FLIP_LEFT_RIGHT):\\n if flip:\\n return img.transpose(flip_type)\\n return img\",\n \"def set_flipped(self, x, y):\\n self.pieces[x + (y * self.width)].set_flipped()\",\n \"def flip(self):\\n if self.is_face_up:\\n arcade.load_texture(self.back_file)\\n self.is_face_up = False\\n else:\\n arcade.load_texture(self.face_file)\\n self.is_face_up = True\",\n \"def flip(self, horizontally):\\n\\t\\tself.currentPixbuf = self.currentPixbuf.flip(horizontally)\\n\\t\\tself.scaleCache[1] = 0\\n\\t\\tgc.collect()\",\n \"def flip_augmentation():\\n return lambda image: ImageOps.flip(image)\",\n \"def flipNormals(self):\\n self.flip = not self.flip\",\n \"def mirrorImage(self):\\n\\n im = Image.open(self.ActivePhoto)\\n out = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\\n out.save(self.ActivePhoto)\\n self.photo.setPixmap(QtGui.QPixmap(self.ActivePhoto))\\n print (\\\"Flipped image\\\")\",\n \"def flip(self):\\n self.width, self.height = self.height, self.width\",\n \"def flip(img, code=0):\\n\\treturn cv2.flip(img, flipCode=code)\",\n \"def vflip(img):\\n if not _is_numpy(img):\\n raise TypeError('img should be Numpy Image. Got {}'.format(type(img)))\\n\\n return np.flipud(img)\",\n \"def flip(self, x: bool, y: bool) -> 'BaseImage':\\n assert isinstance(x, bool)\\n assert isinstance(y, bool)\\n assert (x or y), 'at least one axis should be True'\\n self._surface = pygame.transform.flip(self._surface, x, y)\\n return self\",\n \"def flip_h(image, gt):\\n result_im = cv2.flip(image, 1)\\n result_gt = cv2.flip(gt, 1)\\n\\n return result_im, result_gt\",\n \"def vflip(img, data_format='CHW'):\\n _assert_image_tensor(img, data_format)\\n\\n h_axis = _get_image_h_axis(data_format)\\n\\n return img.flip(axis=[h_axis])\",\n \"def flip_image(image):\\n return cv2.flip(image, flipCode=1)\",\n \"def img_add_flip(arr, flip_horiz = True, flip_vert = False):\\r\\n assert len(arr.shape) == 3, \\\"'arr' input array must be three dimensional\\\"\\r\\n arr_copy = arr.copy()\\r\\n if flip_horiz:\\r\\n arr_copy = np.fliplr(arr_copy)\\r\\n if flip_vert:\\r\\n arr_copy = np.flipud(arr_copy)\\r\\n return arr_copy\",\n \"def flip(self, horizontal):\\n try:\\n self._is_transformable()\\n horizontal = get_int(horizontal)\\n except NotTransformable as e:\\n self._app[\\\"statusbar\\\"].message(str(e) + \\\" flip\\\", \\\"error\\\")\\n return\\n except StringConversionError as e:\\n self._app[\\\"statusbar\\\"].message(str(e), \\\"error\\\")\\n return\\n images = self.get_images(\\\"Flipped\\\")\\n # Apply changes\\n for fil in images:\\n if fil not in self._changes:\\n self._changes[fil] = [0, 0, 0]\\n if horizontal:\\n self._changes[fil][1] = \\\\\\n (self._changes[fil][1] + 1) % 2\\n else:\\n self._changes[fil][2] = \\\\\\n (self._changes[fil][2] + 1) % 2\\n # Flip the image shown\\n if self._app.get_path() in images:\\n self.emit(\\\"changed\\\", \\\"flip\\\", horizontal)\\n # Reload thumbnails of flipped images immediately\\n if self._app[\\\"thumbnail\\\"].toggled:\\n self.apply()\",\n \"def collate_fn_flip(self, batch):\\n FT = torch.FloatTensor\\n img, uvd_gt = zip(*batch)\\n flip = random.randint(1, 10000)%2\\n # Do flipping\\n # 0 = left, 1 = right\\n hand_side = 1\\n if flip:\\n hand_side = 0 \\n\\n new_img = []\\n new_uvd = []\\n for i, u in batch:\\n if flip:\\n i = i.transpose(Image.FLIP_LEFT_RIGHT)\\n u[:, 0] = 0.999 - u[:, 0]\\n i = np.asarray(i)\\n i = i/255.0\\n i = IMG.imgshape2torch(i)\\n new_img.append(i)\\n new_uvd.append(u)\\n \\n new_img = FT(new_img)\\n new_uvd = FT(new_uvd)\\n return new_img, new_uvd, hand_side\",\n \"def flip(self, row: int, col: int) -> None:\\n self.state[row, col] = not self.state[row, col]\",\n \"def flip_image(image):\\n\\n return cv2.flip(image, 1)\",\n \"def test_random_vertical_flip(dummy_input):\\n # Test the 2D image: H, W, C\\n image, label = dummy_input(image_size=(512, 512, 3),\\n label_size=(512, 512, 1))\\n transform = RandomVerticalFlip(prob=1)\\n _image, _label = transform(image, label)\\n _image, _label = transform(_image, _label)\\n assert (image == _image).all()\\n assert (label == _label).all()\\n \\n # Test the 3D image: H, W, D, C\\n image, label = dummy_input(image_size=(512, 512, 20, 3),\\n label_size=(512, 512, 20, 1))\\n transform = RandomVerticalFlip(prob=1)\\n _image, _label = transform(image, label)\\n _image, _label = transform(_image, _label)\\n assert (image == _image).all()\\n assert (label == _label).all()\",\n \"def vflip(img):\\n if not _is_numpy_image(img):\\n raise TypeError('img should be nparray Image. Got {}'.format(type(img)))\\n\\n return cv2.flip(img, 0)\",\n \"def flip_image(image, label):\\n # Flip the image\\n cv2.flip(image, 1, image)\\n\\n # Flip the label\\n label[1] = image.shape[1] - label[1]\",\n \"def set_flip(self, flipconv):\\n if flipconv is None:\\n flipconv = 'astro' # default\\n if flipconv == 'astro': self._flip = -1\\n elif flipconv == 'geo': self._flip = 1\\n else: raise ValueError(\\\"flipconv must be 'astro', 'geo' or None for default.\\\")\",\n \"def set_flipout(flipout):\\n if isinstance(flipout, bool):\\n __SETTINGS__._FLIPOUT = flipout\\n else:\\n raise TypeError('flipout must be True or False')\",\n \"def vflip(self):\\n for y in range(0, self.height // 2):\\n for x in range(0, self.width):\\n self._chars[x][y], self._chars[x][self.height - 1 - y] = self._chars[x][self.height - 1 - y], self._chars[x][y]\\n self._fginfo[x][y], self._fginfo[x][self.height - 1 - y] = self._fginfo[x][self.height - 1 - y], self._fginfo[x][y]\\n self._bginfo[x][y], self._bginfo[x][self.height - 1 - y] = self._bginfo[x][self.height - 1 - y], self._bginfo[x][y]\\n self._strDirty = True\",\n \"def mirror(image):\\n\\n return cv2.flip(image, 1)\",\n \"def saveflip(image, fname, outpath, axis='x', preserve_name=False):\\n if not preserve_name:\\n fpath = genSavePath(outpath, fname, modstring=f\\\"mirror_{axis}\\\")\\n else:\\n fpath = genSavePath(outpath, fname)\\n im = copy(image)\\n if axis == 'x':\\n im = im.transpose(Image.FLIP_LEFT_RIGHT)\\n elif axis == 'y':\\n im = im.transpose(Image.FLIP_TOP_BOTTOM)\\n else:\\n raise Exception('No valid axis procvided for flipping: {} - received value: {}'.format(fname, axis))\\n try:\\n im.save(fpath, subsample=\\\"keep\\\", qtables=image.quantization, optimize=True)\\n\\n except IOError as m:\\n print( \\\"Flipped({}) image creation failed for: {}. \\\\nReason:{}\\\".format(axis,fname,m))\",\n \"def _augment(img):\\r\\n return flip(img, axis=2)\",\n \"def flip_horizontal(img):\\r\\n #reading image\\r\\n im = Image.open(\\\"filename\\\")\\r\\n\\r\\n #flipping image horizontally\\r\\n newimg = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\\r\\n \\r\\n return img\",\n \"def flip_image(image_path, saved_location):\\n image_obj = Image.open(image_path)\\n rotated_image = image_obj.transpose(Image.FLIP_LEFT_RIGHT)\\n rotated_image.save(saved_location)\",\n \"def flip_image(image, direction):\\n prevShape = image.shape\\n image, reshaped = reshape_to_cv_format(image, False)\\n image = cv.flip(image, direction)\\n if reshaped: \\n image = image.reshape(prevShape)\\n return image\",\n \"def setFlag(self):\\n if self.inPlay and not self.shown:\\n self.flag = not(self.flag)\\n image_index = 11 if self.flag else 10\\n self.configure(image = Tile.images[image_index])\\n return 1 if self.flag else -1\\n return 0\",\n \"def flip_image_horizontal(image):\\n return cv.flip(image, 0)\",\n \"def flip(self, xflip=True, yflip=False):\\n self.drawer.flush()\\n img = self.img\\n if xflip: img = img.transpose(PIL.Image.FLIP_LEFT_RIGHT)\\n if yflip: img = img.transpose(PIL.Image.FLIP_TOP_BOTTOM)\\n self.img = img\\n self.update_drawer_img()\\n return self\",\n \"def _augment(img):\\n return flip(img, axis=2)\",\n \"def flip(self):\\n self.align = self._left if self.align == self._right else self._right\\n self.group.layout_all()\",\n \"def flip_rotate(img):\\r\\n\\r\\n choice = int(8*np.random.rand())\\r\\n \\r\\n if choice == 0:\\r\\n return img\\r\\n if choice == 1:\\r\\n return np.rot90(img, 1)\\r\\n if choice == 2:\\r\\n return np.rot90(img, 2)\\r\\n if choice == 3:\\r\\n return np.rot90(img, 3)\\r\\n if choice == 4:\\r\\n return np.flip(img, 0)\\r\\n if choice == 5:\\r\\n return np.flip(img, 1)\\r\\n if choice == 6:\\r\\n return np.flip(np.rot90(img, 1), 0)\\r\\n if choice == 7:\\r\\n return np.flip(np.rot90(img, 1), 1)\",\n \"def check_flip(origin_imgs, result_imgs, flip_type):\\n n, _, _, _ = np.shape(origin_imgs)\\n if flip_type == 'horizontal':\\n for i in range(n):\\n if np.any(result_imgs[i] != np.fliplr(origin_imgs[i])):\\n return False\\n else:\\n # yapf: disable\\n for i in range(n):\\n if np.any(result_imgs[i] != np.transpose(np.fliplr(np.transpose(origin_imgs[i], (1, 0, 2))), (1, 0, 2))): # noqa:E501\\n return False\\n # yapf: enable\\n return True\",\n \"def reversible(self) -> bool:\\n xy_row = np.column_stack(\\n (\\n np.linspace(\\n -self.imgsz[0] / (2 * self.f[0]),\\n self.imgsz[0] / (2 * self.f[0]),\\n int(self.imgsz[0]),\\n ),\\n np.zeros(int(self.imgsz[0])),\\n )\\n )\\n dxy = self._distort(xy_row)\\n continuous_row = np.all(dxy[1:, 0] >= dxy[:-1, 0])\\n xy_col = np.column_stack(\\n (\\n np.zeros(int(self.imgsz[1])),\\n np.linspace(\\n -self.imgsz[1] / (2 * self.f[1]),\\n self.imgsz[1] / (2 * self.f[1]),\\n int(self.imgsz[1]),\\n ),\\n )\\n )\\n dxy = self._distort(xy_col)\\n continuous_col = np.all(dxy[1:, 1] >= dxy[:-1, 1])\\n return continuous_row and continuous_col\",\n \"def on_IV_mode_toggled(self, checked):\\n # TODO: not implemented yet\\n if checked:\\n self.vimode = 0\\n qmdz_const.VI_MODE = 0\\n self.sample_id.setText(\\\"IV_test\\\")\\n self.VI_MPL.clear_curve()\\n self.VI_MPL.set_iv_mode()\",\n \"def readout_flipped(self, iamp):\\n flipped = ct.c_int()\\n self.lib.IsReadoutFlippedByAmplifier(ct.c_int(iamp),\\n ct.pointer(flipped))\\n return bool(flipped.value)\",\n \"def fl_flip_yorigin():\\n _fl_flip_yorigin = library.cfuncproto(\\n library.load_so_libforms(), \\\"fl_flip_yorigin\\\",\\\\\\n None, [],\\\\\\n \\\"\\\"\\\"void fl_flip_yorigin()\\\"\\\"\\\")\\n _fl_flip_yorigin()\",\n \"def flip_frame(frame, flip_code):\\n return cv.flip(frame, flip_code)\",\n \"def flip(self) -> int:\\n self.flags = ~(self.flags)\\n return self.flags\",\n \"def set_flip_board(self, new_value: bool) -> None:\\n self._flip_board = new_value\",\n \"def _flip_y(self, zoom, row):\\n\\n if row is None or zoom is None:\\n raise TypeError(\\\"zoom and row cannot be null\\\")\\n\\n return (2 ** zoom) - 1 - row\",\n \"def random_flip(image ):\\n if random.randint(0,1):\\n image = flipud(image) # vertical flip\\n if random.randint(0,1):\\n image = fliplr(image) # horizontal flip\\n return image\",\n \"def fliplr(img):\\n inv_idx = torch.arange(img.size(3) - 1, -1, -1).long() # N x C x H x W\\n img_flip = img.index_select(3, inv_idx)\\n\\n return img_flip\",\n \"def invert(self, img):\\n return self.inverse()(img)\",\n \"def flip(h):\\n return np.flip(h)\",\n \"def flip(h):\\n return np.flip(h)\",\n \"def collate_fn_no_flip(self, batch):\\n FT = torch.FloatTensor\\n img, uvd_gt = zip(*batch)\\n\\n new_img = []\\n new_uvd = []\\n for i, u in batch:\\n if self.pred_img_side == 'left':\\n i = i.transpose(Image.FLIP_LEFT_RIGHT)\\n u[:, 0] = 0.999 - u[:, 0]\\n i = np.asarray(i)\\n i = i/255.0\\n i = IMG.imgshape2torch(i)\\n new_img.append(i)\\n new_uvd.append(u)\\n \\n new_img = FT(new_img)\\n new_uvd = FT(new_uvd)\\n return new_img, new_uvd\",\n \"def invert(self, val):\\n self._invert = val\\n if val:\\n self.write_cmd(self.CMD_SET_DISP_REVERSE)\\n else:\\n self.write_cmd(self.CMD_SET_DISP_NORMAL)\",\n \"def random_vertical_filp(self, img, p = 0.5):\\n if self.decision(p):\\n img = cv2.flip(img, 0)\\n return img\",\n \"def __splitOrientation(self, checked):\\n if checked:\\n self.setSplitOrientation(Qt.Horizontal)\\n self.splitViewAct.setIcon(\\n UI.PixmapCache.getIcon(\\\"splitHorizontal.png\\\"))\\n self.splitRemoveAct.setIcon(\\n UI.PixmapCache.getIcon(\\\"remsplitHorizontal.png\\\"))\\n self.newDocumentSplitViewAct.setIcon(\\n UI.PixmapCache.getIcon(\\\"splitHorizontal.png\\\"))\\n else:\\n self.setSplitOrientation(Qt.Vertical)\\n self.splitViewAct.setIcon(\\n UI.PixmapCache.getIcon(\\\"splitVertical.png\\\"))\\n self.splitRemoveAct.setIcon(\\n UI.PixmapCache.getIcon(\\\"remsplitVertical.png\\\"))\\n self.newDocumentSplitViewAct.setIcon(\\n UI.PixmapCache.getIcon(\\\"splitVertical.png\\\"))\\n Preferences.setUI(\\\"SplitOrientationVertical\\\", checked)\",\n \"def transpose(self, method):\\r\\n w, h = self.size\\r\\n if method == FLIP_LEFT_RIGHT:\\r\\n _im = cv2.flip(self._instance, 1)\\r\\n elif method == FLIP_TOP_BOTTOM:\\r\\n _im = cv2.flip(self._instance, 0)\\r\\n elif method == ROTATE_90:\\r\\n _im = self.rotate_bound(270)\\r\\n x = self.size[0]//2-self.size[1]//2\\r\\n box = (0, x, self.size[0], x+self.size[1])\\r\\n _im = self.crop(box, _im)\\r\\n elif method == ROTATE_180:\\r\\n _im = self.rotate(180, self._instance)\\r\\n elif method == ROTATE_270:\\r\\n _im = self.rotate_bound(90)\\r\\n x = self.size[0]//2-self.size[1]//2\\r\\n box = (0, x, self.size[0], x+self.size[1])\\r\\n _im = self.crop(box, _im)\\r\\n if isinstance(_im, Image):\\r\\n return _im\\r\\n elif isinstance(_im, np.ndarray):\\r\\n return Image(_im)\",\n \"def orient(self,Y):\\r\\n self.orientation[Y]+=1\\r\\n if self.orientation[Y]>3:\\r\\n self.orientation[Y]=0\\r\\n if self.orientation[Y]<0:\\r\\n self.orientation[Y]=3\\r\\n self.can.delete(self.image_bateau[Y])\\r\\n self.image_bateau[Y]=self.create_image(self.img[self.orientation[Y]][Y],0,0)\\r\\n self.affichage(Y)\",\n \"def flip_axes(input_file, flipx=True, flipy=True, flipz=False,\\n use_matrix=False, use_header=True):\\n import os\\n import numpy as np\\n import nibabel as nb\\n\\n # Load image volume\\n img = nb.load(input_file)\\n dat = img.get_data()\\n if use_matrix:\\n mat = img.get_affine()\\n if use_header:\\n hdr = img.get_header()\\n lenx, leny, lenz = np.shape(dat)\\n dat_new = np.zeros((lenx, leny, lenz))\\n\\n # Flip x\\n if flipx:\\n for x in range(lenx):\\n dat_new[lenx-1-x,:,:] = dat[x,:,:]\\n\\n # Flip y\\n if flipy:\\n for y in range(leny):\\n dat_new[:,leny-1-y,:] = dat[:,y,:]\\n\\n # Flip z\\n if flipz:\\n for z in range(lenz):\\n dat_new[:,:,lenz-1-z] = dat[:,:,z]\\n\\n # Save output\\n out_file = 'reorient_' + os.path.basename(input_file)\\n if use_matrix:\\n if use_header:\\n img = nb.Nifti1Image(dat_new, mat, hdr)\\n else:\\n img = nb.Nifti1Image(dat_new, mat)\\n elif use_header:\\n img = nb.Nifti1Image(dat_new, np.eye(4,4), hdr)\\n else:\\n img = nb.Nifti1Image(dat_new, np.eye(4,4))\\n\\n img.to_filename(out_file)\\n\\n return out_file\",\n \"def flip(self, bev_direction='horizontal', points=None):\\n assert bev_direction in ('horizontal', 'vertical')\\n if bev_direction == 'horizontal':\\n self.tensor[:, 0::7] = -self.tensor[:, 0::7]\\n if self.with_yaw:\\n self.tensor[:, 6] = -self.tensor[:, 6] + np.pi\\n elif bev_direction == 'vertical':\\n self.tensor[:, 2::7] = -self.tensor[:, 2::7]\\n if self.with_yaw:\\n self.tensor[:, 6] = -self.tensor[:, 6]\\n\\n if points is not None:\\n assert isinstance(points, (torch.Tensor, np.ndarray, BasePoints))\\n if isinstance(points, (torch.Tensor, np.ndarray)):\\n if bev_direction == 'horizontal':\\n points[:, 0] = -points[:, 0]\\n elif bev_direction == 'vertical':\\n points[:, 2] = -points[:, 2]\\n elif isinstance(points, BasePoints):\\n points.flip(bev_direction)\\n return points\",\n \"def horizontal_flip() -> Callable:\\n return lambda img: TF.hflip(img)\",\n \"def flip_boxes_vertically(boxes):\\n # Flip boxes vertically\\n ymin, xmin, ymax, xmax = tf.split(value=boxes, num_or_size_splits=4, axis=1)\\n flipped_ymin = tf.subtract(1.0, ymax)\\n flipped_ymax = tf.subtract(1.0, ymin)\\n flipped_boxes = tf.concat([flipped_ymin, xmin, flipped_ymax, xmax], axis=1)\\n return flipped_boxes\",\n \"def rotateYRight(self):\\n MV = self.MV\\n MV[:3, 0] = 0, 1, 0 # 1st col is right vector, make it point along y axis\\n # set middle middle and middle right values to zero:\\n MV[1, 1] = 0\\n MV[1, 2] = 0\\n a = MV[0, 1] # grab top middle value\\n b = np.sqrt(1 - a**2) # calc new complementary value to get normalized vectors\\n if MV[2, 1] < 0:\\n b = -b # keep b -ve, reduce jumping around of axes\\n MV[2, 1] = b\\n MV[0, 2] = b\\n MV[2, 2] = -a # needs to be -ve of MV[0, 1]\\n self.MV = MV\",\n \"def rotateYRight(self):\\n MV = self.MV\\n MV[:3, 0] = 0, 1, 0 # 1st col is right vector, make it point along y axis\\n # set middle middle and middle right values to zero:\\n MV[1, 1] = 0\\n MV[1, 2] = 0\\n a = MV[0, 1] # grab top middle value\\n b = np.sqrt(1 - a**2) # calc new complementary value to get normalized vectors\\n if MV[2, 1] < 0:\\n b = -b # keep b -ve, reduce jumping around of axes\\n MV[2, 1] = b\\n MV[0, 2] = b\\n MV[2, 2] = -a # needs to be -ve of MV[0, 1]\\n self.MV = MV\",\n \"def flip(self, axes=None, inplace=False, i=False):\\n d = _inplace_enabled_define_and_cleanup(self)\\n super(DimensionCoordinate, d).flip(axes=axes, inplace=True)\\n\\n direction = d._custom.get(\\\"direction\\\")\\n if direction is not None:\\n d._custom[\\\"direction\\\"] = not direction\\n\\n return d\",\n \"def translate_image_vertical(image, translationFactor):\\n\\n # create vertical translation matrix\\n tm = np.float32([[1, 0, 0],\\n [0, 1, translationFactor]])\\n return translate_image(image, tm)\",\n \"def setInverted(self, state=True):\\n self.__inverted = state\",\n \"def horizontal_flip(img, steering_angle):\\n flipped = cv2.flip(img, 1) # positive (>0) flip code means flipping about y-axis\\n steering_angle = steering_angle * -1 # change sign of steering angle to account for flip\\n return flipped, steering_angle\",\n \"def _rotate(self):\\n \\r\\n if self.clr == 1: # (default rotation) \\r\\n # o o o o \\r\\n # o x x o x o o x\\r\\n # o o o o\\r\\n _colOffsets = [[-1,-1, 0, 0], [-1, 0, 0, 1], [ 1, 1, 0, 0], [ 1, 0, 0,-1]] #\\r\\n _rowOffsets = [[ 1, 0, 0,-1], [-1,-1, 0, 0], [-1, 0, 0, 1], [ 1, 1, 0, 0]] #\\r\\n elif self.clr == 2:\\r\\n # o o o o \\r\\n # o x o x x o x o\\r\\n # o o o o\\r\\n _colOffsets = [[-1,-1, 0, 0], [ 1, 0, 0,-1], [ 1, 1, 0, 0], [-1, 0, 0, 1]] #\\r\\n _rowOffsets = [[-1, 0, 0, 1], [-1,-1, 0, 0], [ 1, 0, 0,-1], [ 1, 1, 0, 0]] #\\n \\r\\n elif self.clr == 3: # \\r\\n # o o o o \\r\\n # x o x o x o x o\\r\\n # o o o o\\n \\r\\n _colOffsets = [[-1, 0, 0, 0], [-1,-1, 0, 1], [ 1, 0, 0, 0], [ 1, 1, 0,-1]] #\\r\\n _rowOffsets = [[ 1, 1, 0,-1], [-1, 0, 0, 0], [-1,-1, 0, 1], [ 1, 0, 0, 0]] #\\n \\r\\n elif self.clr == 4:\\r\\n # o o o o \\r\\n # x o x o x o x o\\r\\n # o o o o\\r\\n _colOffsets = [[-1, 0, 0, 0], [1, 1, 0, -1], [1, 0, 0,0], [-1, -1, 0,1]]\\n _rowOffsets = [[-1,-1, 0, 1], [-1,0, 0, 0], [1,1, 0,-1], [1,0, 0, 0]]\\n \\r\\n elif self.clr == 5: # o o\\r\\n # o x \\r\\n # x o x o o o o o x o\\r\\n # o o \\r\\n _colOffsets = [[ 0, 0, 0, 0], [ 2, 1, 0,-1], [ 0, 0, 0, 0], [-2,-1, 0, 1]] #\\r\\n _rowOffsets = [[-2,-1, 0, 1], [ 0, 0, 0, 0], [ 2, 1, 0,-1], [ 0, 0, 0, 0]] #\\r\\n elif self.clr == 6: #\\r\\n # o o o \\r\\n # o x o x o x o o x o\\r\\n # o o o \\r\\n _colOffsets = [[ 0,-1, 0, 0], [-1, 0, 0, 1], [ 0, 1, 0, 0], [ 1, 0, 0,-1]] #\\r\\n _rowOffsets = [[ 1, 0, 0,-1], [ 0,-1, 0, 0], [-1, 0, 0, 1], [ 0, 1, 0, 0]] #\\r\\n elif self.clr == 7: # \\r\\n # o o o o o o o o\\r\\n # o x o x o x o x\\r\\n # \\r\\n _colOffsets = [[-1,-1, 0, 0], [-1,-1, 0, 0], [-1,-1, 0, 0], [-1,-1, 0, 0]] #@@\\r\\n _rowOffsets = [[ 0,-1, 0,-1], [ 0,-1, 0,-1], [ 0,-1, 0,-1], [ 0,-1, 0,-1]] #@@\\n \\r\\n self._colOffsets = _colOffsets[self._rot] #@@\\r\\n self._rowOffsets = _rowOffsets[self._rot] #@@\\r\\n self._update() #@@\\r\",\n \"def flip_tile(self, tile, flag=False):\\n selected_tile = self.stack[tile]\\n\\n if flag == True:\\n if self.flags_remaining == 0:\\n raise ValueError(\\\"No flags left\\\")\\n else:\\n selected_tile['flag']=True\\n self.flags_remaining -= 1\\n\\n else:\\n if selected_tile['flag'] == True:\\n selected_tile['flag'] == False\\n self.flags_remaining += 1\\n\\n else:\\n self.stack[tile]['flip'] = True\\n self.tiles_remaining -= 1\\n if selected_tile['value'] == 'bomb':\\n self.end_game()\\n elif selected_tile['value'] == 0:\\n self.blank_tile_cascade(tile)\\n self.check_win()\",\n \"def sym_right_img(img):\\n img = img.transpose(Image.FLIP_LEFT_RIGHT)\\n return sym_left_img(img)\",\n \"def __flip(self, image, landmarks, run_prob=0.5):\\n if np.random.rand() < run_prob:\\n return image, landmarks\\n image = np.fliplr(image)\\n landmarks[:, 0] = image.shape[1] - landmarks[:, 0]\\n landmarks = LandmarkHelper.flip(landmarks, landmarks.shape[0])\\n return image, landmarks\",\n \"def random_flip(self, image, label, horizontal=False):\\n\\n flip = 1\\n rand_float = uniform(0, 1)\\n\\n if horizontal:\\n # 1 == vertical flip\\n # 0 == horizontal flip\\n flip = randint(0, 1)\\n\\n if rand_float > 0.5:\\n image = cv2.flip(image, flip)\\n label = cv2.flip(label, flip)\\n\\n return image, label\",\n \"def mirror(img):\\n return img[:, ::-1]\",\n \"def flip(self, p):\\n return -p\",\n \"def flip(imgs):\\n x = random.choice([-1, 0, 1, 2])\\n if x == 2:\\n return imgs\\n else:\\n return [cv2.flip(img, x) for img in imgs]\",\n \"def flip(tensor, axis=None):\\n raise NotImplementedError\",\n \"def __update_col_facedown(self, col):\\n all_is_facedown = True\\n # Loop all card in column\\n for card in self.solitaire[col]:\\n # If no card is represented\\n if card == 0:\\n break\\n # If at least 1 card is faceup we return from method\\n if not card.is_facedown:\\n all_is_facedown = False\\n return\\n # If all card is facedown, we can flip and reviel a new card\\n # so we have one less card facing down in that column\\n if all_is_facedown:\\n if self.col_facedown[col] > 0:\\n print(f\\\"Vend kort i kolonne {col}\\\")\\n self.col_facedown[col] -= 1\",\n \"def flipAndInvertImage2(self, A: List[List[int]]) -> List[List[int]]:\\n def invert(x):\\n if x:\\n return 0\\n else:\\n return 1\\n\\n for row in A:\\n left, right = 0, len(row)-1\\n while left <= right:\\n row[left], row[right] = invert(row[right]), invert(row[left])\\n left += 1\\n right -= 1\\n\\n return A\",\n \"def evert(self):\\n for e in self.edges:\\n self.invert()\\n for f in self.faces:\\n f.invert()\",\n \"def convert_flip(g, op, block):\\n\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n axis = op.attr(\\\"axis\\\")\\n\\n for i, ax in enumerate(axis):\\n if i == 0:\\n out = _op.reverse(x, ax)\\n else:\\n out = _op.reverse(out, ax)\\n\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def lr_flip(self):\\n for g in self.grid:\\n g.reverse()\",\n \"def set_invert_display(enable):\\n if enable:\\n send_command(0xA7)\\n else:\\n send_command(0xA6)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73209965","0.70142406","0.68551445","0.66779745","0.66683435","0.666765","0.65579903","0.64983195","0.64376324","0.64257395","0.6424698","0.6389282","0.63263226","0.63111866","0.63103646","0.630324","0.6244989","0.61426216","0.6092576","0.60797507","0.60258675","0.59888154","0.5978035","0.59627616","0.59263426","0.590511","0.5888896","0.58764815","0.5850129","0.58486706","0.5841394","0.5838484","0.581671","0.58117527","0.5808985","0.5775403","0.5746161","0.56744534","0.5664703","0.5655347","0.5641214","0.56228924","0.5619947","0.55938333","0.5588591","0.55819005","0.55508286","0.5531665","0.5519797","0.54935944","0.54807156","0.54732925","0.54693234","0.54477584","0.54453427","0.54450387","0.541083","0.540221","0.5396986","0.5396422","0.5393892","0.5385508","0.5379279","0.53634775","0.53513014","0.5341227","0.533776","0.5329209","0.5329209","0.53242207","0.53175616","0.5283458","0.5253648","0.5227469","0.52151585","0.5211796","0.52039546","0.51980835","0.519186","0.5189389","0.5189389","0.51860654","0.51535076","0.51487494","0.5145134","0.513986","0.51398367","0.51343954","0.51330453","0.5132112","0.5131454","0.5123822","0.5116976","0.51101166","0.51087505","0.510457","0.5091377","0.5087573","0.50843245","0.50798744"],"string":"[\n \"0.73209965\",\n \"0.70142406\",\n \"0.68551445\",\n \"0.66779745\",\n \"0.66683435\",\n \"0.666765\",\n \"0.65579903\",\n \"0.64983195\",\n \"0.64376324\",\n \"0.64257395\",\n \"0.6424698\",\n \"0.6389282\",\n \"0.63263226\",\n \"0.63111866\",\n \"0.63103646\",\n \"0.630324\",\n \"0.6244989\",\n \"0.61426216\",\n \"0.6092576\",\n \"0.60797507\",\n \"0.60258675\",\n \"0.59888154\",\n \"0.5978035\",\n \"0.59627616\",\n \"0.59263426\",\n \"0.590511\",\n \"0.5888896\",\n \"0.58764815\",\n \"0.5850129\",\n \"0.58486706\",\n \"0.5841394\",\n \"0.5838484\",\n \"0.581671\",\n \"0.58117527\",\n \"0.5808985\",\n \"0.5775403\",\n \"0.5746161\",\n \"0.56744534\",\n \"0.5664703\",\n \"0.5655347\",\n \"0.5641214\",\n \"0.56228924\",\n \"0.5619947\",\n \"0.55938333\",\n \"0.5588591\",\n \"0.55819005\",\n \"0.55508286\",\n \"0.5531665\",\n \"0.5519797\",\n \"0.54935944\",\n \"0.54807156\",\n \"0.54732925\",\n \"0.54693234\",\n \"0.54477584\",\n \"0.54453427\",\n \"0.54450387\",\n \"0.541083\",\n \"0.540221\",\n \"0.5396986\",\n \"0.5396422\",\n \"0.5393892\",\n \"0.5385508\",\n \"0.5379279\",\n \"0.53634775\",\n \"0.53513014\",\n \"0.5341227\",\n \"0.533776\",\n \"0.5329209\",\n \"0.5329209\",\n \"0.53242207\",\n \"0.53175616\",\n \"0.5283458\",\n \"0.5253648\",\n \"0.5227469\",\n \"0.52151585\",\n \"0.5211796\",\n \"0.52039546\",\n \"0.51980835\",\n \"0.519186\",\n \"0.5189389\",\n \"0.5189389\",\n \"0.51860654\",\n \"0.51535076\",\n \"0.51487494\",\n \"0.5145134\",\n \"0.513986\",\n \"0.51398367\",\n \"0.51343954\",\n \"0.51330453\",\n \"0.5132112\",\n \"0.5131454\",\n \"0.5123822\",\n \"0.5116976\",\n \"0.51101166\",\n \"0.51087505\",\n \"0.510457\",\n \"0.5091377\",\n \"0.5087573\",\n \"0.50843245\",\n \"0.50798744\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8431753"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94982,"cells":{"query":{"kind":"string","value":"Set a flag indicating whether the image should be flipped horizontally"},"document":{"kind":"string","value":"def setHorizontalFlip(self, flag):\n\t\tself.flipHorizontally = flag"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def flip_horizontal(img):\r\n #reading image\r\n im = Image.open(\"filename\")\r\n\r\n #flipping image horizontally\r\n newimg = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\r\n \r\n return img","def flip_image_horizontal(image):\n return cv.flip(image, 0)","def flip(self, horizontally):\n\t\tself.currentPixbuf = self.currentPixbuf.flip(horizontally)\n\t\tself.scaleCache[1] = 0\n\t\tgc.collect()","def setVerticalFlip(self, flag):\n\t\tif self.ext.lower() in [\"png\", \"jpg\", \"jpeg\"]:\n\t\t\tself.flipVertically = not flag\n\t\telse:\n\t\t\tself.flipVertically = flag","def flip(img, boolean=True):\n return pg.transform.flip(img, boolean, False)","def flip(self, horizontal):\n try:\n self._is_transformable()\n horizontal = get_int(horizontal)\n except NotTransformable as e:\n self._app[\"statusbar\"].message(str(e) + \" flip\", \"error\")\n return\n except StringConversionError as e:\n self._app[\"statusbar\"].message(str(e), \"error\")\n return\n images = self.get_images(\"Flipped\")\n # Apply changes\n for fil in images:\n if fil not in self._changes:\n self._changes[fil] = [0, 0, 0]\n if horizontal:\n self._changes[fil][1] = \\\n (self._changes[fil][1] + 1) % 2\n else:\n self._changes[fil][2] = \\\n (self._changes[fil][2] + 1) % 2\n # Flip the image shown\n if self._app.get_path() in images:\n self.emit(\"changed\", \"flip\", horizontal)\n # Reload thumbnails of flipped images immediately\n if self._app[\"thumbnail\"].toggled:\n self.apply()","def flip(self):\n \n if self.faceup:\n self.faceup = False\n else:\n self.faceup = True","def flip(self, xbool, ybool):\n self._surf = pygame.transform.flip(self._surf, xbool, ybool).convert_alpha()","def flip_image(img, vert=True):\n if vert:\n return img.transpose(Image.FLIP_TOP_BOTTOM)\n else:\n return img.transpose(Image.FLIP_LEFT_RIGHT)","def flip(self):","def __flip(img, flip, flip_type=Image.FLIP_LEFT_RIGHT):\n if flip:\n return img.transpose(flip_type)\n return img","def flip(self, mode='h'):\n # TODO: Implement the flip function. Remember to record the boolean values is_horizontal_flip and\n # is_vertical_flip.\n if mode == 'h':\n self.is_horizontal_flip = True\n self.x = np.flipud(self.x)\n elif mode == 'v':\n self.is_vertical_flip = True\n self.x = np.fliplr(self.x)\n else:\n self.is_vertical_flip = True\n self.is_horizontal_flip = True\n self.x = np.fliplr(self.x)\n self.x = np.flipud(self.x)\n # raise NotImplementedError\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################","def mirrorImage(self):\n\n im = Image.open(self.ActivePhoto)\n out = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\n out.save(self.ActivePhoto)\n self.photo.setPixmap(QtGui.QPixmap(self.ActivePhoto))\n print (\"Flipped image\")","def flip_faceup(self):\r\n self.faceup = True","def img_add_flip(arr, flip_horiz = True, flip_vert = False):\r\n assert len(arr.shape) == 3, \"'arr' input array must be three dimensional\"\r\n arr_copy = arr.copy()\r\n if flip_horiz:\r\n arr_copy = np.fliplr(arr_copy)\r\n if flip_vert:\r\n arr_copy = np.flipud(arr_copy)\r\n return arr_copy","def horizontal_flip(img, steering_angle):\n flipped = cv2.flip(img, 1) # positive (>0) flip code means flipping about y-axis\n steering_angle = steering_angle * -1 # change sign of steering angle to account for flip\n return flipped, steering_angle","def horizontal_flip() -> Callable:\n return lambda img: TF.hflip(img)","def flipNormals(self):\n self.flip = not self.flip","def vflip(img):\n #if not _is_pil_image(img):\n # raise TypeError('img should be PIL Image. Got {}'.format(type(img)))\n\n return img.transpose(Image.FLIP_TOP_BOTTOM)","def set_flipped(self, x, y):\n self.pieces[x + (y * self.width)].set_flipped()","def flip_augmentation():\n return lambda image: ImageOps.flip(image)","def set_flip(self, val):\n self.flip = val","def flip(self, x: bool, y: bool) -> 'BaseImage':\n assert isinstance(x, bool)\n assert isinstance(y, bool)\n assert (x or y), 'at least one axis should be True'\n self._surface = pygame.transform.flip(self._surface, x, y)\n return self","def td_flip(self):\n self.cw_rotate()\n self.cw_rotate()\n self.lr_flip()\n self.find_edges()","def flip(self, bev_direction: str = 'horizontal') -> None:\n pass","def check_flip(origin_imgs, result_imgs, flip_type):\n n, _, _, _ = np.shape(origin_imgs)\n if flip_type == 'horizontal':\n for i in range(n):\n if np.any(result_imgs[i] != np.fliplr(origin_imgs[i])):\n return False\n else:\n # yapf: disable\n for i in range(n):\n if np.any(result_imgs[i] != np.transpose(np.fliplr(np.transpose(origin_imgs[i], (1, 0, 2))), (1, 0, 2))): # noqa:E501\n return False\n # yapf: enable\n return True","def flip(self):\n self.width, self.height = self.height, self.width","def set_flip(self, flipconv):\n if flipconv is None:\n flipconv = 'astro' # default\n if flipconv == 'astro': self._flip = -1\n elif flipconv == 'geo': self._flip = 1\n else: raise ValueError(\"flipconv must be 'astro', 'geo' or None for default.\")","def flip(img, code=0):\n\treturn cv2.flip(img, flipCode=code)","def flip_horizontal(picture: Image) -> Image:\r\n \r\n hflip = copy(picture)\r\n width = get_width(picture)\r\n height = get_height(picture)\r\n \r\n for x in range(width):\r\n for y in range(height):\r\n original_hpixel = get_color(picture, x, y)\r\n hflip_pixel = (width - 1) - x\r\n set_color(hflip, hflip_pixel, y, original_hpixel)\r\n \r\n return hflip","def flip_vertical(img):\r\n #reading image\r\n im = Image.open(\"filename\")\r\n\r\n #flipping image vertically\r\n newimg = im.transpose(PIL.Image.FLIP_TOP_BOTTOM)\r\n return img","def flip_image(image):\n return cv2.flip(image, flipCode=1)","def flip_horizontally(img, gt_boxes):\n flipped_img = tf.image.flip_left_right(img)\n flipped_gt_boxes = tf.stack([gt_boxes[..., 0],\n 1.0 - gt_boxes[..., 3],\n gt_boxes[..., 2],\n 1.0 - gt_boxes[..., 1]], -1)\n return flipped_img, flipped_gt_boxes","def flip_image_vertical(image):\n return cv.flip(image, 1)","def flip_image(image):\n\n return cv2.flip(image, 1)","def flip(self):\n if self.is_face_up:\n arcade.load_texture(self.back_file)\n self.is_face_up = False\n else:\n arcade.load_texture(self.face_file)\n self.is_face_up = True","def mirror(image):\n\n return cv2.flip(image, 1)","def flip(self, xflip=True, yflip=False):\n self.drawer.flush()\n img = self.img\n if xflip: img = img.transpose(PIL.Image.FLIP_LEFT_RIGHT)\n if yflip: img = img.transpose(PIL.Image.FLIP_TOP_BOTTOM)\n self.img = img\n self.update_drawer_img()\n return self","def setFlag(self):\n if self.inPlay and not self.shown:\n self.flag = not(self.flag)\n image_index = 11 if self.flag else 10\n self.configure(image = Tile.images[image_index])\n return 1 if self.flag else -1\n return 0","def flip(self, row: int, col: int) -> None:\n self.state[row, col] = not self.state[row, col]","def flip_image(image, label):\n # Flip the image\n cv2.flip(image, 1, image)\n\n # Flip the label\n label[1] = image.shape[1] - label[1]","def fliplr(img):\n inv_idx = torch.arange(img.size(3) - 1, -1, -1).long() # N x C x H x W\n img_flip = img.index_select(3, inv_idx)\n\n return img_flip","def _augment(img):\r\n return flip(img, axis=2)","def random_flip(self, image, label, horizontal=False):\n\n flip = 1\n rand_float = uniform(0, 1)\n\n if horizontal:\n # 1 == vertical flip\n # 0 == horizontal flip\n flip = randint(0, 1)\n\n if rand_float > 0.5:\n image = cv2.flip(image, flip)\n label = cv2.flip(label, flip)\n\n return image, label","def flip_image(image, direction):\n prevShape = image.shape\n image, reshaped = reshape_to_cv_format(image, False)\n image = cv.flip(image, direction)\n if reshaped: \n image = image.reshape(prevShape)\n return image","def collate_fn_flip(self, batch):\n FT = torch.FloatTensor\n img, uvd_gt = zip(*batch)\n flip = random.randint(1, 10000)%2\n # Do flipping\n # 0 = left, 1 = right\n hand_side = 1\n if flip:\n hand_side = 0 \n\n new_img = []\n new_uvd = []\n for i, u in batch:\n if flip:\n i = i.transpose(Image.FLIP_LEFT_RIGHT)\n u[:, 0] = 0.999 - u[:, 0]\n i = np.asarray(i)\n i = i/255.0\n i = IMG.imgshape2torch(i)\n new_img.append(i)\n new_uvd.append(u)\n \n new_img = FT(new_img)\n new_uvd = FT(new_uvd)\n return new_img, new_uvd, hand_side","def flip(self):\n self.align = self._left if self.align == self._right else self._right\n self.group.layout_all()","def saveflip(image, fname, outpath, axis='x', preserve_name=False):\n if not preserve_name:\n fpath = genSavePath(outpath, fname, modstring=f\"mirror_{axis}\")\n else:\n fpath = genSavePath(outpath, fname)\n im = copy(image)\n if axis == 'x':\n im = im.transpose(Image.FLIP_LEFT_RIGHT)\n elif axis == 'y':\n im = im.transpose(Image.FLIP_TOP_BOTTOM)\n else:\n raise Exception('No valid axis procvided for flipping: {} - received value: {}'.format(fname, axis))\n try:\n im.save(fpath, subsample=\"keep\", qtables=image.quantization, optimize=True)\n\n except IOError as m:\n print( \"Flipped({}) image creation failed for: {}. \\nReason:{}\".format(axis,fname,m))","def vflip(img, data_format='CHW'):\n _assert_image_tensor(img, data_format)\n\n h_axis = _get_image_h_axis(data_format)\n\n return img.flip(axis=[h_axis])","def _augment(img):\n return flip(img, axis=2)","def flip_frame(frame, flip_code):\n return cv.flip(frame, flip_code)","def flip_image(image_path, saved_location):\n image_obj = Image.open(image_path)\n rotated_image = image_obj.transpose(Image.FLIP_LEFT_RIGHT)\n rotated_image.save(saved_location)","def flip_axes(input_file, flipx=True, flipy=True, flipz=False,\n use_matrix=False, use_header=True):\n import os\n import numpy as np\n import nibabel as nb\n\n # Load image volume\n img = nb.load(input_file)\n dat = img.get_data()\n if use_matrix:\n mat = img.get_affine()\n if use_header:\n hdr = img.get_header()\n lenx, leny, lenz = np.shape(dat)\n dat_new = np.zeros((lenx, leny, lenz))\n\n # Flip x\n if flipx:\n for x in range(lenx):\n dat_new[lenx-1-x,:,:] = dat[x,:,:]\n\n # Flip y\n if flipy:\n for y in range(leny):\n dat_new[:,leny-1-y,:] = dat[:,y,:]\n\n # Flip z\n if flipz:\n for z in range(lenz):\n dat_new[:,:,lenz-1-z] = dat[:,:,z]\n\n # Save output\n out_file = 'reorient_' + os.path.basename(input_file)\n if use_matrix:\n if use_header:\n img = nb.Nifti1Image(dat_new, mat, hdr)\n else:\n img = nb.Nifti1Image(dat_new, mat)\n elif use_header:\n img = nb.Nifti1Image(dat_new, np.eye(4,4), hdr)\n else:\n img = nb.Nifti1Image(dat_new, np.eye(4,4))\n\n img.to_filename(out_file)\n\n return out_file","def flip_rotate(img):\r\n\r\n choice = int(8*np.random.rand())\r\n \r\n if choice == 0:\r\n return img\r\n if choice == 1:\r\n return np.rot90(img, 1)\r\n if choice == 2:\r\n return np.rot90(img, 2)\r\n if choice == 3:\r\n return np.rot90(img, 3)\r\n if choice == 4:\r\n return np.flip(img, 0)\r\n if choice == 5:\r\n return np.flip(img, 1)\r\n if choice == 6:\r\n return np.flip(np.rot90(img, 1), 0)\r\n if choice == 7:\r\n return np.flip(np.rot90(img, 1), 1)","def vflip(img):\n if not _is_numpy(img):\n raise TypeError('img should be Numpy Image. Got {}'.format(type(img)))\n\n return np.flipud(img)","def fotoXO(self):\n\t\ttry:\n\t\t\timageP = self.cam.get_image()\n\t\t\tself.image = pygame.transform.flip(imageP, True, False)\n\t\texcept:\n\t\t\tpass\n\t\treturn self.image","def flip(self) -> int:\n self.flags = ~(self.flags)\n return self.flags","def flip_x(self):\n self.x_lim_helper.flip_limits()","def flip_x(self):\n self.x_lim_helper.flip_limits()","def flipMat(image):\n retImage = cv.CreateMat(image.rows, image.cols, image.type)\n height = image.rows\n transMatrix = cv.CreateMatHeader(2, 3, cv.CV_32FC1)\n narr = numpy.array([[1, 0, 0], [0, -1, height]], numpy.float32)\n cv.SetData(transMatrix, narr, cv.CV_AUTOSTEP)\n cv.WarpAffine(image, retImage, transMatrix)\n return retImage","def reversible(self) -> bool:\n xy_row = np.column_stack(\n (\n np.linspace(\n -self.imgsz[0] / (2 * self.f[0]),\n self.imgsz[0] / (2 * self.f[0]),\n int(self.imgsz[0]),\n ),\n np.zeros(int(self.imgsz[0])),\n )\n )\n dxy = self._distort(xy_row)\n continuous_row = np.all(dxy[1:, 0] >= dxy[:-1, 0])\n xy_col = np.column_stack(\n (\n np.zeros(int(self.imgsz[1])),\n np.linspace(\n -self.imgsz[1] / (2 * self.f[1]),\n self.imgsz[1] / (2 * self.f[1]),\n int(self.imgsz[1]),\n ),\n )\n )\n dxy = self._distort(xy_col)\n continuous_col = np.all(dxy[1:, 1] >= dxy[:-1, 1])\n return continuous_row and continuous_col","def flip(tensor, axis=None):\n raise NotImplementedError","def flip_h(image, gt):\n result_im = cv2.flip(image, 1)\n result_gt = cv2.flip(gt, 1)\n\n return result_im, result_gt","def random_flip(image ):\n if random.randint(0,1):\n image = flipud(image) # vertical flip\n if random.randint(0,1):\n image = fliplr(image) # horizontal flip\n return image","def vflip(img):\n if not _is_numpy_image(img):\n raise TypeError('img should be nparray Image. Got {}'.format(type(img)))\n\n return cv2.flip(img, 0)","def __flip(self, image, landmarks, run_prob=0.5):\n if np.random.rand() < run_prob:\n return image, landmarks\n image = np.fliplr(image)\n landmarks[:, 0] = image.shape[1] - landmarks[:, 0]\n landmarks = LandmarkHelper.flip(landmarks, landmarks.shape[0])\n return image, landmarks","def flip(self, axes=None, inplace=False, i=False):\n d = _inplace_enabled_define_and_cleanup(self)\n super(DimensionCoordinate, d).flip(axes=axes, inplace=True)\n\n direction = d._custom.get(\"direction\")\n if direction is not None:\n d._custom[\"direction\"] = not direction\n\n return d","def mirror_horiz(pixels):\n copy = blank_image(len(pixels), len(pixels[0])) \n for r in range(len(pixels)):\n for c in range(len(pixels[0])):\n copy[r][c] = pixels[r][c]\n a = len(pixels[0])//2\n for r in range(len(pixels)):\n for c in range(a, len(pixels[0])):\n copy[r][c] = copy[r][-c-1]\n return copy","def _move_left(self):\n self.x -= self.settings.mario_speed\n if self.settings.direction == 1:\n self.image = pygame.transform.flip(self.image, True, False)\n self.settings.direction = -1","def random_horizontal_flip(image, boxes=None, masks=None, seed=None):\n return preprocessor.random_horizontal_flip(image, boxes, masks, seed=seed)","def flip(self, flip_x=True, flip_y=True):\n self._version += 1\n self._surf = pygame.transform.flip(self._surf,\n flip_x, flip_y).convert_alpha()\n return self","def hflip(img):\n #if not _is_pil_image(img):\n # raise TypeError('img should be PIL Image. Got {}'.format(type(img)))\n\n return img.transpose(Image.FLIP_LEFT_RIGHT)","def flip(flip_x=False, flip_y=False): \r\n x, y = 1, 1\r\n if flip_x:\r\n x = np.random.choice((-1,1))\r\n if flip_y:\r\n y = np.random.choice((-1,1))\r\n return np.array(((x, 0, 0),\r\n (0, y, 0),\r\n (0, 0, 1)), dtype=np.float)","def problem1():\n\n img = load_image(\"data/a1p1.png\")\n display_image(img)\n\n save_as_npy(\"a1p1.npy\", img)\n\n img1 = load_npy(\"a1p1.npy\")\n display_image(img1)\n\n img2 = mirror_horizontal(img1)\n display_image(img2)\n\n display_images(img1, img2)","def image_augmentation(img):\n return np.fliplr(img)","def flip(self, x, y):\n self.pieces[x + (y * self.width)].flip()","def image_flip(image, direction):\n im_size = image.get_shape().as_list()\n if direction == 'left_right':\n flip_function = tf.image.random_flip_left_right\n elif direction == 'up_down':\n flip_function = tf.image.random_flip_up_down\n else:\n raise NotImplementedError\n\n if len(im_size) == 3:\n return flip_function(image)\n elif len(im_size) == 4:\n if im_size[-1] > 1:\n raise NotImplementedError\n trans_image = tf.transpose(tf.squeeze(image), [1, 2, 0])\n flip_image = tf.expand_dims(\n tf.transpose(flip_function(trans_image), [2, 0, 1]), axis=-1)\n return flip_image\n else:\n raise NotImplementedError","def flipAndInvertImage(self, A: List[List[int]]) -> List[List[int]]:\n return [list(map(lambda x: 0 if x else 1, row[::-1])) for row in A]","def readout_flipped(self, iamp):\n flipped = ct.c_int()\n self.lib.IsReadoutFlippedByAmplifier(ct.c_int(iamp),\n ct.pointer(flipped))\n return bool(flipped.value)","def flip(imgs):\n x = random.choice([-1, 0, 1, 2])\n if x == 2:\n return imgs\n else:\n return [cv2.flip(img, x) for img in imgs]","def flip_vertical(original_image: Image) -> Image :\r\n \r\n new_image = copy(original_image)\r\n \r\n pixel_width = get_width(original_image)\r\n pixel_height = get_height(original_image) \r\n\r\n \r\n for x in range(pixel_width) :\r\n for y in range(pixel_height) :\r\n original_vertical_pixel = get_color(original_image, x, y)\r\n opposite_vertical_pixel = pixel_height - 1 - y\r\n set_color(new_image, x, opposite_vertical_pixel, original_vertical_pixel)\r\n \r\n return new_image","def flip_icon(icon):\n\n return (\"X\" if icon == \"O\" else \"O\")","def test_random_horizontal_flip(dummy_input):\n # Test the 2D image: H, W, C\n image, label = dummy_input(image_size=(512, 512, 3),\n label_size=(512, 512, 1))\n transform = RandomHorizontalFlip( prob=1)\n _image, _label = transform(image, label)\n _image, _label = transform(_image, _label)\n assert (image == _image).all()\n assert (label == _label).all()\n \n # Test the 3D image: H, W, D, C\n image, label = dummy_input(image_size=(512, 512, 20, 3),\n label_size=(512, 512, 20, 1))\n transform = RandomHorizontalFlip(prob=1)\n _image, _label = transform(image, label)\n _image, _label = transform(_image, _label)\n assert (image == _image).all()\n assert (label == _label).all()","def lr_flip(self):\n for g in self.grid:\n g.reverse()","def flip_ras_lps(vol, affine):\n vol_flipped = np.flip(vol, (0,1))\n affine_flipped = affine.copy()\n affine_flipped[0,-1] = (-1 * affine @ np.array([vol.shape[0]-1,0,0,1]))[0]\n affine_flipped[1,-1] = (-1 * affine @ np.array([0,vol.shape[1]-1,0,1]))[1]\n\n return vol_flipped, affine_flipped","def _check_flip(origin_imgs, result_imgs):\n h, w, c = origin_imgs.shape\n for i in range(h):\n for j in range(w):\n for k in range(c):\n if result_imgs[i, j, k] != origin_imgs[i, w - 1 - j, k]:\n return False\n return True","def test_flip_vertical() -> None:\n original = create_image(3, 2)\n set_color(original, 0, 0, create_color(0, 0, 0))\n set_color(original, 1, 0, create_color(90, 90, 90))\n set_color(original, 2, 0, create_color(255, 255, 255))\n set_color(original, 0, 1, create_color(10, 10, 10))\n set_color(original, 1, 1, create_color(0, 0, 0))\n set_color(original, 2, 1, create_color(90, 90, 90))\n \n expected = create_image(3, 2)\n set_color(expected, 0, 0, create_color(10, 10, 10))\n set_color(expected, 1, 0, create_color(0, 0, 0))\n set_color(expected, 2, 0, create_color(90, 90, 90))\n set_color(expected, 0, 1, create_color(0, 0, 0))\n set_color(expected, 1, 1, create_color(90, 90, 90))\n set_color(expected, 2, 1, create_color(255, 255, 255))\n \n flipped_vertical = flip_vertical(original)\n \n for x, y, col in flipped_vertical: # tests each colour of each pixel of the filtered sample image and compares it to the expected image\n check_equal('Checking pixel @(' + str(x) + ', ' + str(y) + ')', col, get_color(expected, x, y))","def hflip(self):\n self.leftimg, self.rightimg = self.rightimg, self.leftimg","def rotate_right_90(img):\r\n #reading image\r\n im = Image.open(\"filename\")\r\n \r\n #flipping image 90 degrees\r\n newimg = im.transpose(PIL.Image.ROTATE_90)\r\n \r\n return img","def flipAndInvertImage2(self, A: List[List[int]]) -> List[List[int]]:\n def invert(x):\n if x:\n return 0\n else:\n return 1\n\n for row in A:\n left, right = 0, len(row)-1\n while left <= right:\n row[left], row[right] = invert(row[right]), invert(row[left])\n left += 1\n right -= 1\n\n return A","def transform(self, mat: TxMatrix) -> None:\n self.rotation = self.rotation - int(0x10000 * mat.angle / math.pi / 2) & 0xFFFF\n if mat.flipped:\n self.flip_y = not self.flip_y\n self.rotation = -self.rotation & 0xFFFF","def set_invert_display(enable):\n if enable:\n send_command(0xA7)\n else:\n send_command(0xA6)","def flip(self, p):\n return -p","def toggle_back_mid(self, checked):\n if self.material_background:\n if checked:\n image = self.parent.data.materials[self.tile.background_material].midimage\n else:\n image = self.parent.data.materials[self.tile.background_material].bgimage\n self.material_background.setPixmap(image)\n if self.mod_background:\n if checked:\n image = self.parent.data.matmods[self.tile.background_mod].midimage\n else:\n image = self.parent.data.matmods[self.tile.background_mod].bgimage\n self.mod_background.setPixmap(image)","def toggle_wireframe(self):\n self.view['wireframe'] = not self.view['wireframe']\n self.update_flags()","def sym_left_img(img):\n cropped = img.crop(box=(0, 0, img.width / 2, img.height))\n mirror = cropped.transpose(Image.FLIP_LEFT_RIGHT)\n combine = Image.new('RGB', (cropped.width * 2, cropped.height), 'white')\n combine.paste(cropped, (0, 0, cropped.width, cropped.height))\n combine.paste(mirror, (cropped.width, 0, cropped.width * 2, cropped.height))\n return combine","def flip_row(rows, i):\n for j in range(order):\n rows[i][j] = -rows[i][j]","def flip_tile(self, tile, flag=False):\n selected_tile = self.stack[tile]\n\n if flag == True:\n if self.flags_remaining == 0:\n raise ValueError(\"No flags left\")\n else:\n selected_tile['flag']=True\n self.flags_remaining -= 1\n\n else:\n if selected_tile['flag'] == True:\n selected_tile['flag'] == False\n self.flags_remaining += 1\n\n else:\n self.stack[tile]['flip'] = True\n self.tiles_remaining -= 1\n if selected_tile['value'] == 'bomb':\n self.end_game()\n elif selected_tile['value'] == 0:\n self.blank_tile_cascade(tile)\n self.check_win()","def collate_fn_no_flip(self, batch):\n FT = torch.FloatTensor\n img, uvd_gt = zip(*batch)\n\n new_img = []\n new_uvd = []\n for i, u in batch:\n if self.pred_img_side == 'left':\n i = i.transpose(Image.FLIP_LEFT_RIGHT)\n u[:, 0] = 0.999 - u[:, 0]\n i = np.asarray(i)\n i = i/255.0\n i = IMG.imgshape2torch(i)\n new_img.append(i)\n new_uvd.append(u)\n \n new_img = FT(new_img)\n new_uvd = FT(new_uvd)\n return new_img, new_uvd","def random_horizontal_flip(img, angle, prob=0.5):\n\n if np.random.rand() <= prob:\n img = cv2.flip(img, 1)\n angle = -angle\n\n return img, angle"],"string":"[\n \"def flip_horizontal(img):\\r\\n #reading image\\r\\n im = Image.open(\\\"filename\\\")\\r\\n\\r\\n #flipping image horizontally\\r\\n newimg = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\\r\\n \\r\\n return img\",\n \"def flip_image_horizontal(image):\\n return cv.flip(image, 0)\",\n \"def flip(self, horizontally):\\n\\t\\tself.currentPixbuf = self.currentPixbuf.flip(horizontally)\\n\\t\\tself.scaleCache[1] = 0\\n\\t\\tgc.collect()\",\n \"def setVerticalFlip(self, flag):\\n\\t\\tif self.ext.lower() in [\\\"png\\\", \\\"jpg\\\", \\\"jpeg\\\"]:\\n\\t\\t\\tself.flipVertically = not flag\\n\\t\\telse:\\n\\t\\t\\tself.flipVertically = flag\",\n \"def flip(img, boolean=True):\\n return pg.transform.flip(img, boolean, False)\",\n \"def flip(self, horizontal):\\n try:\\n self._is_transformable()\\n horizontal = get_int(horizontal)\\n except NotTransformable as e:\\n self._app[\\\"statusbar\\\"].message(str(e) + \\\" flip\\\", \\\"error\\\")\\n return\\n except StringConversionError as e:\\n self._app[\\\"statusbar\\\"].message(str(e), \\\"error\\\")\\n return\\n images = self.get_images(\\\"Flipped\\\")\\n # Apply changes\\n for fil in images:\\n if fil not in self._changes:\\n self._changes[fil] = [0, 0, 0]\\n if horizontal:\\n self._changes[fil][1] = \\\\\\n (self._changes[fil][1] + 1) % 2\\n else:\\n self._changes[fil][2] = \\\\\\n (self._changes[fil][2] + 1) % 2\\n # Flip the image shown\\n if self._app.get_path() in images:\\n self.emit(\\\"changed\\\", \\\"flip\\\", horizontal)\\n # Reload thumbnails of flipped images immediately\\n if self._app[\\\"thumbnail\\\"].toggled:\\n self.apply()\",\n \"def flip(self):\\n \\n if self.faceup:\\n self.faceup = False\\n else:\\n self.faceup = True\",\n \"def flip(self, xbool, ybool):\\n self._surf = pygame.transform.flip(self._surf, xbool, ybool).convert_alpha()\",\n \"def flip_image(img, vert=True):\\n if vert:\\n return img.transpose(Image.FLIP_TOP_BOTTOM)\\n else:\\n return img.transpose(Image.FLIP_LEFT_RIGHT)\",\n \"def flip(self):\",\n \"def __flip(img, flip, flip_type=Image.FLIP_LEFT_RIGHT):\\n if flip:\\n return img.transpose(flip_type)\\n return img\",\n \"def flip(self, mode='h'):\\n # TODO: Implement the flip function. Remember to record the boolean values is_horizontal_flip and\\n # is_vertical_flip.\\n if mode == 'h':\\n self.is_horizontal_flip = True\\n self.x = np.flipud(self.x)\\n elif mode == 'v':\\n self.is_vertical_flip = True\\n self.x = np.fliplr(self.x)\\n else:\\n self.is_vertical_flip = True\\n self.is_horizontal_flip = True\\n self.x = np.fliplr(self.x)\\n self.x = np.flipud(self.x)\\n # raise NotImplementedError\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\",\n \"def mirrorImage(self):\\n\\n im = Image.open(self.ActivePhoto)\\n out = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\\n out.save(self.ActivePhoto)\\n self.photo.setPixmap(QtGui.QPixmap(self.ActivePhoto))\\n print (\\\"Flipped image\\\")\",\n \"def flip_faceup(self):\\r\\n self.faceup = True\",\n \"def img_add_flip(arr, flip_horiz = True, flip_vert = False):\\r\\n assert len(arr.shape) == 3, \\\"'arr' input array must be three dimensional\\\"\\r\\n arr_copy = arr.copy()\\r\\n if flip_horiz:\\r\\n arr_copy = np.fliplr(arr_copy)\\r\\n if flip_vert:\\r\\n arr_copy = np.flipud(arr_copy)\\r\\n return arr_copy\",\n \"def horizontal_flip(img, steering_angle):\\n flipped = cv2.flip(img, 1) # positive (>0) flip code means flipping about y-axis\\n steering_angle = steering_angle * -1 # change sign of steering angle to account for flip\\n return flipped, steering_angle\",\n \"def horizontal_flip() -> Callable:\\n return lambda img: TF.hflip(img)\",\n \"def flipNormals(self):\\n self.flip = not self.flip\",\n \"def vflip(img):\\n #if not _is_pil_image(img):\\n # raise TypeError('img should be PIL Image. Got {}'.format(type(img)))\\n\\n return img.transpose(Image.FLIP_TOP_BOTTOM)\",\n \"def set_flipped(self, x, y):\\n self.pieces[x + (y * self.width)].set_flipped()\",\n \"def flip_augmentation():\\n return lambda image: ImageOps.flip(image)\",\n \"def set_flip(self, val):\\n self.flip = val\",\n \"def flip(self, x: bool, y: bool) -> 'BaseImage':\\n assert isinstance(x, bool)\\n assert isinstance(y, bool)\\n assert (x or y), 'at least one axis should be True'\\n self._surface = pygame.transform.flip(self._surface, x, y)\\n return self\",\n \"def td_flip(self):\\n self.cw_rotate()\\n self.cw_rotate()\\n self.lr_flip()\\n self.find_edges()\",\n \"def flip(self, bev_direction: str = 'horizontal') -> None:\\n pass\",\n \"def check_flip(origin_imgs, result_imgs, flip_type):\\n n, _, _, _ = np.shape(origin_imgs)\\n if flip_type == 'horizontal':\\n for i in range(n):\\n if np.any(result_imgs[i] != np.fliplr(origin_imgs[i])):\\n return False\\n else:\\n # yapf: disable\\n for i in range(n):\\n if np.any(result_imgs[i] != np.transpose(np.fliplr(np.transpose(origin_imgs[i], (1, 0, 2))), (1, 0, 2))): # noqa:E501\\n return False\\n # yapf: enable\\n return True\",\n \"def flip(self):\\n self.width, self.height = self.height, self.width\",\n \"def set_flip(self, flipconv):\\n if flipconv is None:\\n flipconv = 'astro' # default\\n if flipconv == 'astro': self._flip = -1\\n elif flipconv == 'geo': self._flip = 1\\n else: raise ValueError(\\\"flipconv must be 'astro', 'geo' or None for default.\\\")\",\n \"def flip(img, code=0):\\n\\treturn cv2.flip(img, flipCode=code)\",\n \"def flip_horizontal(picture: Image) -> Image:\\r\\n \\r\\n hflip = copy(picture)\\r\\n width = get_width(picture)\\r\\n height = get_height(picture)\\r\\n \\r\\n for x in range(width):\\r\\n for y in range(height):\\r\\n original_hpixel = get_color(picture, x, y)\\r\\n hflip_pixel = (width - 1) - x\\r\\n set_color(hflip, hflip_pixel, y, original_hpixel)\\r\\n \\r\\n return hflip\",\n \"def flip_vertical(img):\\r\\n #reading image\\r\\n im = Image.open(\\\"filename\\\")\\r\\n\\r\\n #flipping image vertically\\r\\n newimg = im.transpose(PIL.Image.FLIP_TOP_BOTTOM)\\r\\n return img\",\n \"def flip_image(image):\\n return cv2.flip(image, flipCode=1)\",\n \"def flip_horizontally(img, gt_boxes):\\n flipped_img = tf.image.flip_left_right(img)\\n flipped_gt_boxes = tf.stack([gt_boxes[..., 0],\\n 1.0 - gt_boxes[..., 3],\\n gt_boxes[..., 2],\\n 1.0 - gt_boxes[..., 1]], -1)\\n return flipped_img, flipped_gt_boxes\",\n \"def flip_image_vertical(image):\\n return cv.flip(image, 1)\",\n \"def flip_image(image):\\n\\n return cv2.flip(image, 1)\",\n \"def flip(self):\\n if self.is_face_up:\\n arcade.load_texture(self.back_file)\\n self.is_face_up = False\\n else:\\n arcade.load_texture(self.face_file)\\n self.is_face_up = True\",\n \"def mirror(image):\\n\\n return cv2.flip(image, 1)\",\n \"def flip(self, xflip=True, yflip=False):\\n self.drawer.flush()\\n img = self.img\\n if xflip: img = img.transpose(PIL.Image.FLIP_LEFT_RIGHT)\\n if yflip: img = img.transpose(PIL.Image.FLIP_TOP_BOTTOM)\\n self.img = img\\n self.update_drawer_img()\\n return self\",\n \"def setFlag(self):\\n if self.inPlay and not self.shown:\\n self.flag = not(self.flag)\\n image_index = 11 if self.flag else 10\\n self.configure(image = Tile.images[image_index])\\n return 1 if self.flag else -1\\n return 0\",\n \"def flip(self, row: int, col: int) -> None:\\n self.state[row, col] = not self.state[row, col]\",\n \"def flip_image(image, label):\\n # Flip the image\\n cv2.flip(image, 1, image)\\n\\n # Flip the label\\n label[1] = image.shape[1] - label[1]\",\n \"def fliplr(img):\\n inv_idx = torch.arange(img.size(3) - 1, -1, -1).long() # N x C x H x W\\n img_flip = img.index_select(3, inv_idx)\\n\\n return img_flip\",\n \"def _augment(img):\\r\\n return flip(img, axis=2)\",\n \"def random_flip(self, image, label, horizontal=False):\\n\\n flip = 1\\n rand_float = uniform(0, 1)\\n\\n if horizontal:\\n # 1 == vertical flip\\n # 0 == horizontal flip\\n flip = randint(0, 1)\\n\\n if rand_float > 0.5:\\n image = cv2.flip(image, flip)\\n label = cv2.flip(label, flip)\\n\\n return image, label\",\n \"def flip_image(image, direction):\\n prevShape = image.shape\\n image, reshaped = reshape_to_cv_format(image, False)\\n image = cv.flip(image, direction)\\n if reshaped: \\n image = image.reshape(prevShape)\\n return image\",\n \"def collate_fn_flip(self, batch):\\n FT = torch.FloatTensor\\n img, uvd_gt = zip(*batch)\\n flip = random.randint(1, 10000)%2\\n # Do flipping\\n # 0 = left, 1 = right\\n hand_side = 1\\n if flip:\\n hand_side = 0 \\n\\n new_img = []\\n new_uvd = []\\n for i, u in batch:\\n if flip:\\n i = i.transpose(Image.FLIP_LEFT_RIGHT)\\n u[:, 0] = 0.999 - u[:, 0]\\n i = np.asarray(i)\\n i = i/255.0\\n i = IMG.imgshape2torch(i)\\n new_img.append(i)\\n new_uvd.append(u)\\n \\n new_img = FT(new_img)\\n new_uvd = FT(new_uvd)\\n return new_img, new_uvd, hand_side\",\n \"def flip(self):\\n self.align = self._left if self.align == self._right else self._right\\n self.group.layout_all()\",\n \"def saveflip(image, fname, outpath, axis='x', preserve_name=False):\\n if not preserve_name:\\n fpath = genSavePath(outpath, fname, modstring=f\\\"mirror_{axis}\\\")\\n else:\\n fpath = genSavePath(outpath, fname)\\n im = copy(image)\\n if axis == 'x':\\n im = im.transpose(Image.FLIP_LEFT_RIGHT)\\n elif axis == 'y':\\n im = im.transpose(Image.FLIP_TOP_BOTTOM)\\n else:\\n raise Exception('No valid axis procvided for flipping: {} - received value: {}'.format(fname, axis))\\n try:\\n im.save(fpath, subsample=\\\"keep\\\", qtables=image.quantization, optimize=True)\\n\\n except IOError as m:\\n print( \\\"Flipped({}) image creation failed for: {}. \\\\nReason:{}\\\".format(axis,fname,m))\",\n \"def vflip(img, data_format='CHW'):\\n _assert_image_tensor(img, data_format)\\n\\n h_axis = _get_image_h_axis(data_format)\\n\\n return img.flip(axis=[h_axis])\",\n \"def _augment(img):\\n return flip(img, axis=2)\",\n \"def flip_frame(frame, flip_code):\\n return cv.flip(frame, flip_code)\",\n \"def flip_image(image_path, saved_location):\\n image_obj = Image.open(image_path)\\n rotated_image = image_obj.transpose(Image.FLIP_LEFT_RIGHT)\\n rotated_image.save(saved_location)\",\n \"def flip_axes(input_file, flipx=True, flipy=True, flipz=False,\\n use_matrix=False, use_header=True):\\n import os\\n import numpy as np\\n import nibabel as nb\\n\\n # Load image volume\\n img = nb.load(input_file)\\n dat = img.get_data()\\n if use_matrix:\\n mat = img.get_affine()\\n if use_header:\\n hdr = img.get_header()\\n lenx, leny, lenz = np.shape(dat)\\n dat_new = np.zeros((lenx, leny, lenz))\\n\\n # Flip x\\n if flipx:\\n for x in range(lenx):\\n dat_new[lenx-1-x,:,:] = dat[x,:,:]\\n\\n # Flip y\\n if flipy:\\n for y in range(leny):\\n dat_new[:,leny-1-y,:] = dat[:,y,:]\\n\\n # Flip z\\n if flipz:\\n for z in range(lenz):\\n dat_new[:,:,lenz-1-z] = dat[:,:,z]\\n\\n # Save output\\n out_file = 'reorient_' + os.path.basename(input_file)\\n if use_matrix:\\n if use_header:\\n img = nb.Nifti1Image(dat_new, mat, hdr)\\n else:\\n img = nb.Nifti1Image(dat_new, mat)\\n elif use_header:\\n img = nb.Nifti1Image(dat_new, np.eye(4,4), hdr)\\n else:\\n img = nb.Nifti1Image(dat_new, np.eye(4,4))\\n\\n img.to_filename(out_file)\\n\\n return out_file\",\n \"def flip_rotate(img):\\r\\n\\r\\n choice = int(8*np.random.rand())\\r\\n \\r\\n if choice == 0:\\r\\n return img\\r\\n if choice == 1:\\r\\n return np.rot90(img, 1)\\r\\n if choice == 2:\\r\\n return np.rot90(img, 2)\\r\\n if choice == 3:\\r\\n return np.rot90(img, 3)\\r\\n if choice == 4:\\r\\n return np.flip(img, 0)\\r\\n if choice == 5:\\r\\n return np.flip(img, 1)\\r\\n if choice == 6:\\r\\n return np.flip(np.rot90(img, 1), 0)\\r\\n if choice == 7:\\r\\n return np.flip(np.rot90(img, 1), 1)\",\n \"def vflip(img):\\n if not _is_numpy(img):\\n raise TypeError('img should be Numpy Image. Got {}'.format(type(img)))\\n\\n return np.flipud(img)\",\n \"def fotoXO(self):\\n\\t\\ttry:\\n\\t\\t\\timageP = self.cam.get_image()\\n\\t\\t\\tself.image = pygame.transform.flip(imageP, True, False)\\n\\t\\texcept:\\n\\t\\t\\tpass\\n\\t\\treturn self.image\",\n \"def flip(self) -> int:\\n self.flags = ~(self.flags)\\n return self.flags\",\n \"def flip_x(self):\\n self.x_lim_helper.flip_limits()\",\n \"def flip_x(self):\\n self.x_lim_helper.flip_limits()\",\n \"def flipMat(image):\\n retImage = cv.CreateMat(image.rows, image.cols, image.type)\\n height = image.rows\\n transMatrix = cv.CreateMatHeader(2, 3, cv.CV_32FC1)\\n narr = numpy.array([[1, 0, 0], [0, -1, height]], numpy.float32)\\n cv.SetData(transMatrix, narr, cv.CV_AUTOSTEP)\\n cv.WarpAffine(image, retImage, transMatrix)\\n return retImage\",\n \"def reversible(self) -> bool:\\n xy_row = np.column_stack(\\n (\\n np.linspace(\\n -self.imgsz[0] / (2 * self.f[0]),\\n self.imgsz[0] / (2 * self.f[0]),\\n int(self.imgsz[0]),\\n ),\\n np.zeros(int(self.imgsz[0])),\\n )\\n )\\n dxy = self._distort(xy_row)\\n continuous_row = np.all(dxy[1:, 0] >= dxy[:-1, 0])\\n xy_col = np.column_stack(\\n (\\n np.zeros(int(self.imgsz[1])),\\n np.linspace(\\n -self.imgsz[1] / (2 * self.f[1]),\\n self.imgsz[1] / (2 * self.f[1]),\\n int(self.imgsz[1]),\\n ),\\n )\\n )\\n dxy = self._distort(xy_col)\\n continuous_col = np.all(dxy[1:, 1] >= dxy[:-1, 1])\\n return continuous_row and continuous_col\",\n \"def flip(tensor, axis=None):\\n raise NotImplementedError\",\n \"def flip_h(image, gt):\\n result_im = cv2.flip(image, 1)\\n result_gt = cv2.flip(gt, 1)\\n\\n return result_im, result_gt\",\n \"def random_flip(image ):\\n if random.randint(0,1):\\n image = flipud(image) # vertical flip\\n if random.randint(0,1):\\n image = fliplr(image) # horizontal flip\\n return image\",\n \"def vflip(img):\\n if not _is_numpy_image(img):\\n raise TypeError('img should be nparray Image. Got {}'.format(type(img)))\\n\\n return cv2.flip(img, 0)\",\n \"def __flip(self, image, landmarks, run_prob=0.5):\\n if np.random.rand() < run_prob:\\n return image, landmarks\\n image = np.fliplr(image)\\n landmarks[:, 0] = image.shape[1] - landmarks[:, 0]\\n landmarks = LandmarkHelper.flip(landmarks, landmarks.shape[0])\\n return image, landmarks\",\n \"def flip(self, axes=None, inplace=False, i=False):\\n d = _inplace_enabled_define_and_cleanup(self)\\n super(DimensionCoordinate, d).flip(axes=axes, inplace=True)\\n\\n direction = d._custom.get(\\\"direction\\\")\\n if direction is not None:\\n d._custom[\\\"direction\\\"] = not direction\\n\\n return d\",\n \"def mirror_horiz(pixels):\\n copy = blank_image(len(pixels), len(pixels[0])) \\n for r in range(len(pixels)):\\n for c in range(len(pixels[0])):\\n copy[r][c] = pixels[r][c]\\n a = len(pixels[0])//2\\n for r in range(len(pixels)):\\n for c in range(a, len(pixels[0])):\\n copy[r][c] = copy[r][-c-1]\\n return copy\",\n \"def _move_left(self):\\n self.x -= self.settings.mario_speed\\n if self.settings.direction == 1:\\n self.image = pygame.transform.flip(self.image, True, False)\\n self.settings.direction = -1\",\n \"def random_horizontal_flip(image, boxes=None, masks=None, seed=None):\\n return preprocessor.random_horizontal_flip(image, boxes, masks, seed=seed)\",\n \"def flip(self, flip_x=True, flip_y=True):\\n self._version += 1\\n self._surf = pygame.transform.flip(self._surf,\\n flip_x, flip_y).convert_alpha()\\n return self\",\n \"def hflip(img):\\n #if not _is_pil_image(img):\\n # raise TypeError('img should be PIL Image. Got {}'.format(type(img)))\\n\\n return img.transpose(Image.FLIP_LEFT_RIGHT)\",\n \"def flip(flip_x=False, flip_y=False): \\r\\n x, y = 1, 1\\r\\n if flip_x:\\r\\n x = np.random.choice((-1,1))\\r\\n if flip_y:\\r\\n y = np.random.choice((-1,1))\\r\\n return np.array(((x, 0, 0),\\r\\n (0, y, 0),\\r\\n (0, 0, 1)), dtype=np.float)\",\n \"def problem1():\\n\\n img = load_image(\\\"data/a1p1.png\\\")\\n display_image(img)\\n\\n save_as_npy(\\\"a1p1.npy\\\", img)\\n\\n img1 = load_npy(\\\"a1p1.npy\\\")\\n display_image(img1)\\n\\n img2 = mirror_horizontal(img1)\\n display_image(img2)\\n\\n display_images(img1, img2)\",\n \"def image_augmentation(img):\\n return np.fliplr(img)\",\n \"def flip(self, x, y):\\n self.pieces[x + (y * self.width)].flip()\",\n \"def image_flip(image, direction):\\n im_size = image.get_shape().as_list()\\n if direction == 'left_right':\\n flip_function = tf.image.random_flip_left_right\\n elif direction == 'up_down':\\n flip_function = tf.image.random_flip_up_down\\n else:\\n raise NotImplementedError\\n\\n if len(im_size) == 3:\\n return flip_function(image)\\n elif len(im_size) == 4:\\n if im_size[-1] > 1:\\n raise NotImplementedError\\n trans_image = tf.transpose(tf.squeeze(image), [1, 2, 0])\\n flip_image = tf.expand_dims(\\n tf.transpose(flip_function(trans_image), [2, 0, 1]), axis=-1)\\n return flip_image\\n else:\\n raise NotImplementedError\",\n \"def flipAndInvertImage(self, A: List[List[int]]) -> List[List[int]]:\\n return [list(map(lambda x: 0 if x else 1, row[::-1])) for row in A]\",\n \"def readout_flipped(self, iamp):\\n flipped = ct.c_int()\\n self.lib.IsReadoutFlippedByAmplifier(ct.c_int(iamp),\\n ct.pointer(flipped))\\n return bool(flipped.value)\",\n \"def flip(imgs):\\n x = random.choice([-1, 0, 1, 2])\\n if x == 2:\\n return imgs\\n else:\\n return [cv2.flip(img, x) for img in imgs]\",\n \"def flip_vertical(original_image: Image) -> Image :\\r\\n \\r\\n new_image = copy(original_image)\\r\\n \\r\\n pixel_width = get_width(original_image)\\r\\n pixel_height = get_height(original_image) \\r\\n\\r\\n \\r\\n for x in range(pixel_width) :\\r\\n for y in range(pixel_height) :\\r\\n original_vertical_pixel = get_color(original_image, x, y)\\r\\n opposite_vertical_pixel = pixel_height - 1 - y\\r\\n set_color(new_image, x, opposite_vertical_pixel, original_vertical_pixel)\\r\\n \\r\\n return new_image\",\n \"def flip_icon(icon):\\n\\n return (\\\"X\\\" if icon == \\\"O\\\" else \\\"O\\\")\",\n \"def test_random_horizontal_flip(dummy_input):\\n # Test the 2D image: H, W, C\\n image, label = dummy_input(image_size=(512, 512, 3),\\n label_size=(512, 512, 1))\\n transform = RandomHorizontalFlip( prob=1)\\n _image, _label = transform(image, label)\\n _image, _label = transform(_image, _label)\\n assert (image == _image).all()\\n assert (label == _label).all()\\n \\n # Test the 3D image: H, W, D, C\\n image, label = dummy_input(image_size=(512, 512, 20, 3),\\n label_size=(512, 512, 20, 1))\\n transform = RandomHorizontalFlip(prob=1)\\n _image, _label = transform(image, label)\\n _image, _label = transform(_image, _label)\\n assert (image == _image).all()\\n assert (label == _label).all()\",\n \"def lr_flip(self):\\n for g in self.grid:\\n g.reverse()\",\n \"def flip_ras_lps(vol, affine):\\n vol_flipped = np.flip(vol, (0,1))\\n affine_flipped = affine.copy()\\n affine_flipped[0,-1] = (-1 * affine @ np.array([vol.shape[0]-1,0,0,1]))[0]\\n affine_flipped[1,-1] = (-1 * affine @ np.array([0,vol.shape[1]-1,0,1]))[1]\\n\\n return vol_flipped, affine_flipped\",\n \"def _check_flip(origin_imgs, result_imgs):\\n h, w, c = origin_imgs.shape\\n for i in range(h):\\n for j in range(w):\\n for k in range(c):\\n if result_imgs[i, j, k] != origin_imgs[i, w - 1 - j, k]:\\n return False\\n return True\",\n \"def test_flip_vertical() -> None:\\n original = create_image(3, 2)\\n set_color(original, 0, 0, create_color(0, 0, 0))\\n set_color(original, 1, 0, create_color(90, 90, 90))\\n set_color(original, 2, 0, create_color(255, 255, 255))\\n set_color(original, 0, 1, create_color(10, 10, 10))\\n set_color(original, 1, 1, create_color(0, 0, 0))\\n set_color(original, 2, 1, create_color(90, 90, 90))\\n \\n expected = create_image(3, 2)\\n set_color(expected, 0, 0, create_color(10, 10, 10))\\n set_color(expected, 1, 0, create_color(0, 0, 0))\\n set_color(expected, 2, 0, create_color(90, 90, 90))\\n set_color(expected, 0, 1, create_color(0, 0, 0))\\n set_color(expected, 1, 1, create_color(90, 90, 90))\\n set_color(expected, 2, 1, create_color(255, 255, 255))\\n \\n flipped_vertical = flip_vertical(original)\\n \\n for x, y, col in flipped_vertical: # tests each colour of each pixel of the filtered sample image and compares it to the expected image\\n check_equal('Checking pixel @(' + str(x) + ', ' + str(y) + ')', col, get_color(expected, x, y))\",\n \"def hflip(self):\\n self.leftimg, self.rightimg = self.rightimg, self.leftimg\",\n \"def rotate_right_90(img):\\r\\n #reading image\\r\\n im = Image.open(\\\"filename\\\")\\r\\n \\r\\n #flipping image 90 degrees\\r\\n newimg = im.transpose(PIL.Image.ROTATE_90)\\r\\n \\r\\n return img\",\n \"def flipAndInvertImage2(self, A: List[List[int]]) -> List[List[int]]:\\n def invert(x):\\n if x:\\n return 0\\n else:\\n return 1\\n\\n for row in A:\\n left, right = 0, len(row)-1\\n while left <= right:\\n row[left], row[right] = invert(row[right]), invert(row[left])\\n left += 1\\n right -= 1\\n\\n return A\",\n \"def transform(self, mat: TxMatrix) -> None:\\n self.rotation = self.rotation - int(0x10000 * mat.angle / math.pi / 2) & 0xFFFF\\n if mat.flipped:\\n self.flip_y = not self.flip_y\\n self.rotation = -self.rotation & 0xFFFF\",\n \"def set_invert_display(enable):\\n if enable:\\n send_command(0xA7)\\n else:\\n send_command(0xA6)\",\n \"def flip(self, p):\\n return -p\",\n \"def toggle_back_mid(self, checked):\\n if self.material_background:\\n if checked:\\n image = self.parent.data.materials[self.tile.background_material].midimage\\n else:\\n image = self.parent.data.materials[self.tile.background_material].bgimage\\n self.material_background.setPixmap(image)\\n if self.mod_background:\\n if checked:\\n image = self.parent.data.matmods[self.tile.background_mod].midimage\\n else:\\n image = self.parent.data.matmods[self.tile.background_mod].bgimage\\n self.mod_background.setPixmap(image)\",\n \"def toggle_wireframe(self):\\n self.view['wireframe'] = not self.view['wireframe']\\n self.update_flags()\",\n \"def sym_left_img(img):\\n cropped = img.crop(box=(0, 0, img.width / 2, img.height))\\n mirror = cropped.transpose(Image.FLIP_LEFT_RIGHT)\\n combine = Image.new('RGB', (cropped.width * 2, cropped.height), 'white')\\n combine.paste(cropped, (0, 0, cropped.width, cropped.height))\\n combine.paste(mirror, (cropped.width, 0, cropped.width * 2, cropped.height))\\n return combine\",\n \"def flip_row(rows, i):\\n for j in range(order):\\n rows[i][j] = -rows[i][j]\",\n \"def flip_tile(self, tile, flag=False):\\n selected_tile = self.stack[tile]\\n\\n if flag == True:\\n if self.flags_remaining == 0:\\n raise ValueError(\\\"No flags left\\\")\\n else:\\n selected_tile['flag']=True\\n self.flags_remaining -= 1\\n\\n else:\\n if selected_tile['flag'] == True:\\n selected_tile['flag'] == False\\n self.flags_remaining += 1\\n\\n else:\\n self.stack[tile]['flip'] = True\\n self.tiles_remaining -= 1\\n if selected_tile['value'] == 'bomb':\\n self.end_game()\\n elif selected_tile['value'] == 0:\\n self.blank_tile_cascade(tile)\\n self.check_win()\",\n \"def collate_fn_no_flip(self, batch):\\n FT = torch.FloatTensor\\n img, uvd_gt = zip(*batch)\\n\\n new_img = []\\n new_uvd = []\\n for i, u in batch:\\n if self.pred_img_side == 'left':\\n i = i.transpose(Image.FLIP_LEFT_RIGHT)\\n u[:, 0] = 0.999 - u[:, 0]\\n i = np.asarray(i)\\n i = i/255.0\\n i = IMG.imgshape2torch(i)\\n new_img.append(i)\\n new_uvd.append(u)\\n \\n new_img = FT(new_img)\\n new_uvd = FT(new_uvd)\\n return new_img, new_uvd\",\n \"def random_horizontal_flip(img, angle, prob=0.5):\\n\\n if np.random.rand() <= prob:\\n img = cv2.flip(img, 1)\\n angle = -angle\\n\\n return img, angle\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7160271","0.6985837","0.6883737","0.6870575","0.6787338","0.67704475","0.6695351","0.6677402","0.6635156","0.6454874","0.64387655","0.64263225","0.6393341","0.6339728","0.63132757","0.6289396","0.61795443","0.61762446","0.61736774","0.6157254","0.6147425","0.61260164","0.61075574","0.61018664","0.6062592","0.6054945","0.60410434","0.60015607","0.6001088","0.5991457","0.5967564","0.5948894","0.59085155","0.590566","0.5890086","0.58447194","0.58341396","0.5822114","0.57834285","0.57498354","0.57327807","0.57313967","0.5724974","0.5715353","0.5708785","0.56937754","0.56833625","0.56514686","0.56082076","0.56058115","0.55757236","0.5573182","0.55610204","0.5543094","0.5506922","0.54723847","0.54723716","0.5471844","0.5471844","0.5471399","0.54678416","0.5464779","0.5457303","0.5455988","0.54501957","0.5448164","0.54275995","0.5426481","0.5411117","0.5397402","0.53971636","0.5388936","0.5365111","0.53272873","0.528007","0.5275459","0.52692276","0.5265063","0.52649516","0.5263534","0.5262168","0.5259047","0.5256096","0.52495414","0.5247168","0.5233755","0.52324945","0.5231468","0.52275014","0.5202341","0.51982844","0.5189252","0.5184262","0.5180183","0.51727295","0.5164444","0.5163008","0.5152905","0.51518524","0.51453954"],"string":"[\n \"0.7160271\",\n \"0.6985837\",\n \"0.6883737\",\n \"0.6870575\",\n \"0.6787338\",\n \"0.67704475\",\n \"0.6695351\",\n \"0.6677402\",\n \"0.6635156\",\n \"0.6454874\",\n \"0.64387655\",\n \"0.64263225\",\n \"0.6393341\",\n \"0.6339728\",\n \"0.63132757\",\n \"0.6289396\",\n \"0.61795443\",\n \"0.61762446\",\n \"0.61736774\",\n \"0.6157254\",\n \"0.6147425\",\n \"0.61260164\",\n \"0.61075574\",\n \"0.61018664\",\n \"0.6062592\",\n \"0.6054945\",\n \"0.60410434\",\n \"0.60015607\",\n \"0.6001088\",\n \"0.5991457\",\n \"0.5967564\",\n \"0.5948894\",\n \"0.59085155\",\n \"0.590566\",\n \"0.5890086\",\n \"0.58447194\",\n \"0.58341396\",\n \"0.5822114\",\n \"0.57834285\",\n \"0.57498354\",\n \"0.57327807\",\n \"0.57313967\",\n \"0.5724974\",\n \"0.5715353\",\n \"0.5708785\",\n \"0.56937754\",\n \"0.56833625\",\n \"0.56514686\",\n \"0.56082076\",\n \"0.56058115\",\n \"0.55757236\",\n \"0.5573182\",\n \"0.55610204\",\n \"0.5543094\",\n \"0.5506922\",\n \"0.54723847\",\n \"0.54723716\",\n \"0.5471844\",\n \"0.5471844\",\n \"0.5471399\",\n \"0.54678416\",\n \"0.5464779\",\n \"0.5457303\",\n \"0.5455988\",\n \"0.54501957\",\n \"0.5448164\",\n \"0.54275995\",\n \"0.5426481\",\n \"0.5411117\",\n \"0.5397402\",\n \"0.53971636\",\n \"0.5388936\",\n \"0.5365111\",\n \"0.53272873\",\n \"0.528007\",\n \"0.5275459\",\n \"0.52692276\",\n \"0.5265063\",\n \"0.52649516\",\n \"0.5263534\",\n \"0.5262168\",\n \"0.5259047\",\n \"0.5256096\",\n \"0.52495414\",\n \"0.5247168\",\n \"0.5233755\",\n \"0.52324945\",\n \"0.5231468\",\n \"0.52275014\",\n \"0.5202341\",\n \"0.51982844\",\n \"0.5189252\",\n \"0.5184262\",\n \"0.5180183\",\n \"0.51727295\",\n \"0.5164444\",\n \"0.5163008\",\n \"0.5152905\",\n \"0.51518524\",\n \"0.51453954\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.83549047"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94983,"cells":{"query":{"kind":"string","value":"check that each image in the list has the same dimensions"},"document":{"kind":"string","value":"def checkImageDimensions(self, filenames):\n\t\ts = None\n\t\thashStr = filenames[:]\n\t\thashStr.sort()\n\t\thashStr = str(hashStr)\n\t\t# check to see if there's already a result of the check for these filenames in the cache\n\t\tif hashStr in self.dimensionCheck:\n\t\t\tLogging.info(\"Using cached result for dimensions check: %s\"%(str(self.dimensionCheck[hashStr])))\n\t\t\treturn self.dimensionCheck[hashStr]\n\t\t\t\n\t\tfor file in filenames:\n\t\t\tif file not in self.imageDims:\n\t\t\t\tprint \"Trying to open\",type(file)\n\t\t\t\ttry:\n\t\t\t\t\tself.ext = file.split(\".\")[-1].upper()\n\t\t\t\t\tif self.ext == \"TIF\":\n\t\t\t\t\t\tself.ext = \"TIFF\"\n\t\t\t\t\tif self.ext == \"JPG\":\n\t\t\t\t\t\tself.ext = \"JPEG\"\n\n\t\t\t\t\tif self.ext == \"VTI\":\n\t\t\t\t\t\treader = vtk.vtkXMLImageReader()\n\t\t\t\t\telse:\n\t\t\t\t\t\treader = eval(\"vtk.vtk%sReader()\"%self.ext)\n\t\t\t\t\treader.SetFileName(file)\n\t\t\t\t\treader.UpdateInformation()\n\t\t\t\texcept IOError, ex:\n\t\t\t\t\ttraceback.print_exc()\n\t\t\t\t\traise Logging.GUIError(\"Cannot open image file\", \"Cannot open image file %s\" % file)\n\n\t\t\t\textent = reader.GetDataExtent()\n\t\t\t\tfSize = (extent[1],extent[3])\n\t\t\t\tself.imageDims[file] = fSize\n\t\t\telse:\n\t\t\t\tfSize = self.imageDims[file]\n\t\t\tif s and fSize != s:\n\t\t\t\tx0, y0 = s\n\t\t\t\tx1, y1 = fSize\n\t\t\t\tself.dimensionCheck[hashStr] = False\n\t\t\t\treturn 0\n\t\t\ts = fSize \n\t\t\tfn = file\n\t\tself.dimensionCheck[hashStr] = True\n\t\treturn 1"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def images_are_present(file_info):\n currentdir = os.path.join(WORKDIR, file_info['folder'])\n if not os.path.exists(currentdir):\n return False\n count = len([x for x in os.listdir(currentdir) if x.endswith('.png')])\n if count != file_info['size']:\n print([x for x in os.listdir(currentdir) if x.endswith('.png')])\n print('Count does not match')\n print(count)\n print(file_info['size'])\n return False\n return True","def _get_consistent_shape(images: Iterable):\n dim0s = []\n dim1s = []\n\n for img in images:\n dim0s.append(img.shape[0])\n dim1s.append(img.shape[1])\n\n assert len(set(dim0s)) == 1 and len(set(dim1s)) == 1, 'Inconsistent shapes.'\n\n return dim0s[0], dim1s[0]","def are_compatible_imgs(one_img, another_img):\n return have_same_shapes(one_img, another_img)","def number_of_images_valid():\r\n if number_of_images_a_valid() and number_of_images_b_valid():\r\n return True\r\n else:\r\n return False","def image_size_exact(self, msg, img_type, height, width,\n target=None):\n height = int(height)\n width = int(width)\n sizes = self._get_sizes(msg, img_type)\n for img in sizes:\n if (img['width'], img['height']) == (width, height):\n return True\n return False","def number_of_images_a_valid():\r\n counter = 0\r\n with os.scandir(os.path.join(dir_path, \"inputs\", \"type_a\")) as filepaths:\r\n for path in filepaths:\r\n extension = os.path.splitext(path)[1].lower()\r\n if extension == \".png\" or extension == \".jpg\":\r\n counter += 1\r\n if counter >= int(number_of_images_a.get()):\r\n return True\r\n else:\r\n messagebox.showwarning(\"Invalid Image Inputs\", (\r\n \"Not enough images of type a to create \"\r\n \"requested grid.\"))\r\n return False","def check_image_size(image_folder_path, height=None, width=None):\n total_img_list = glob.glob(os.path.join(image_folder_path, \"*\"))\n counter = 0\n for image in tqdm(total_img_list, desc=\"Checking in progress\"):\n try:\n img = cv2.imread(image)\n\n # Review Comments:\n #\n # I assume you were trying to initialize width and height\n # if they are not defined by the caller. I have rewritten\n # your code to do this successfully - before you were just\n # comparing the height and width of each image with\n # itself.\n if height is None:\n height = img.shape[1]\n\n if width is None:\n width = img.shape[0]\n\n if not (height == img.shape[1] and width == img.shape[0]):\n counter += 1\n # Review Comments: What exception are you trying to catch here?\n # In general, you should not have a bare except block.\n except:\n print(\"this {} is corrupted\".format(image))\n continue\n return counter","def _autocheck_dimensions(self):\n # W dimensions check list\n assert len(self.W.shape) == 2, f\"W shape should be (N, N) but is {self.W.shape}.\"\n assert self.W.shape[0] == self.W.shape[1], f\"W shape should be (N, N) but is {self.W.shape}.\"\n\n # Win dimensions check list\n assert len(self.Win.shape) == 2, f\"Win shape should be (N, input) but is {self.Win.shape}.\"\n err = f\"Win shape should be ({self.W.shape[1]}, input) but is {self.Win.shape}.\"\n assert self.Win.shape[0] == self.W.shape[0], err\n\n # Wout dimensions check list\n assert len(self.Wout.shape) == 2, f\"Wout shape should be (output, nb_states) but is {self.Wout.shape}.\"\n nb_states = self.Win.shape[1] + self.W.shape[0] + 1 if self.use_raw_inp else self.W.shape[0] + 1\n err = f\"Wout shape should be (output, {nb_states}) but is {self.Wout.shape}.\"\n assert self.Wout.shape[1] == nb_states, err\n\n # Wfb dimensions check list\n if self.Wfb is not None:\n assert len(self.Wfb.shape) == 2, f\"Wfb shape should be (input, output) but is {self.Wfb.shape}.\"\n err = f\"Wfb shape should be ({self.Win.shape[0]}, {self.Wout.shape[0]}) but is {self.Wfb.shape}.\"\n assert (self.Win.shape[0],self.Wout.shape[0]) == self.Wfb.shape, err","def _filter_imgs(self, min_size=32):\n valid_inds = []\n for i, img_info in enumerate(self.img_infos):\n if min(img_info['width'], img_info['height']) >= min_size:\n valid_inds.append(i)\n return valid_inds","def _filter_imgs(self, min_size=32):\n valid_inds = []\n for i, img_info in enumerate(self.img_infos):\n if min(img_info['width'], img_info['height']) >= min_size:\n valid_inds.append(i)\n return valid_inds","def ensure_images_have_the_same_properties(images, properties):\n for prop in properties:\n vals = np.asarray([getattr(image, prop) for image in images])\n if not all(vals == vals[0]):\n raise ValueError(f'To be coadded, images must all have the same {prop}. '\n f'These images had: {[(image.id, getattr(image, prop)) for image in images]}.')","def _check_dimensions(self, workspace_to_check):\n for i in range(self._raw_ws.getNumDims()):\n if self._raw_ws.getDimension(i).getNBins() != workspace_to_check._raw_ws.getDimension(i).getNBins():\n return False\n return True","def check_images():\n\n print(f'Looking for duplicate images...')\n\n for image in images_in_directory:\n duplicate = check_image_for_duplicates(image)\n\n if (duplicate):\n print(f'Found {duplicate} to be a duplicate image of: {image}')\n remove_image(duplicate)\n pass","def check_image_dimensions(image_paths, image_height, image_width):\n logging.info('Using image height, width %s', str((image_height, image_width)))\n\n bad_images = []\n\n for path in image_paths:\n logging.info('Trying to read image %s', path)\n image = microscopeimagequality.dataset_creation.read_16_bit_greyscale(path)\n\n if image.shape[0] < image_height or image.shape[1] < image_width:\n bad_images.append(path)\n logging.info('Image %s dimension %s is too small.', path, str(image.shape))\n\n logging.info('Done checking images')\n\n logging.info('Found %d bad images.', len(bad_images))\n\n if bad_images:\n raise ValueError('Found %d bad images! \\n %s' % (len(bad_images), '\\n'.join(bad_images)))","def __len__(self):\n return len(self.images)","def __len__(self):\n return len(self.images)","def check_shapes(arrs):\r\n shps = [i.shape for i in arrs]\r\n eq = np.all(np.array([shps[0] == i for i in shps[1:]]))\r\n err = \"Arrays arr not of the same shape...\"\r\n if not eq:\r\n raise ValueError(\"{}\\n{}\".format(err, shps))","def _filter_imgs(self, min_size=32):\n valid_inds = []\n for i, img_info in enumerate(self.img_infos):\n # Filter out empty images\n if img_info['ann']['bboxes'].shape[0] > 0:\n if min(img_info['width'], img_info['height']) >= min_size:\n valid_inds.append(i)\n return valid_inds","def n_compare(im_list, label_list, figsize=(12,8), zoom_box_coord=None,\n zoom_box_color='red'):\n # Error checks.\n # =============\n # 1. Matching lengths of image and lebal lists.\n if len(im_list) != len(label_list):\n raise ValueError(f\"\"\"List length mismatch: {len(im_list)} != {len(label_list)}. \"\"\"\n \"\"\"Length of arguments 'im_list' and 'label_list' must be the same.\"\"\")\n\n # 2. At least 2 images are present in the input list.\n if len(im_list) < 2:\n raise ValueError(f\"Input list to argument 'im_list' must contain 2 or more items.\")\n \n # Infer values for plotting.\n n_rows = 1 if zoom_box_coord is None else 2\n n_cols = len(im_list)\n scaling_factor_x = im_list[1].shape[1] / im_list[0].shape[1]\n scaling_factor_y = im_list[1].shape[0] / im_list[0].shape[0]\n \n # Arrange and display images.\n # ===========================\n _, ax = plt.subplots(nrows=n_rows, ncols=n_cols, figsize=figsize)\n\n for i, im_i in enumerate(im_list):\n if n_rows == 1:\n # 1. If only a single row (no zoom).\n ax[i].imshow(im_i)\n ax[i].set_title(label_list[i])\n ax[i].get_xaxis().set_visible(False)\n ax[i].get_yaxis().set_visible(False)\n else:\n # 2. If 2 rows are to be plotted (zoom is applied).\n ax[0][i].imshow(im_i)\n ax[0][i].set_title(label_list[i])\n ax[0][i].get_xaxis().set_visible(False)\n ax[0][i].get_yaxis().set_visible(False)\n\n # 2.1. Handle box coordinates and scaling thereof.\n if i == 0:\n xy = (zoom_box_coord[0], zoom_box_coord[1])\n rect = patches.Rectangle(xy,\n zoom_box_coord[2],\n zoom_box_coord[3],\n linewidth=1,edgecolor='red',facecolor='none')\n new_zoom_coords = (xy[0], xy[1], zoom_box_coord[2], zoom_box_coord[3])\n else:\n xy = (int(zoom_box_coord[0]*scaling_factor_x), int(zoom_box_coord[1]*scaling_factor_y))\n rect = patches.Rectangle(xy,\n int(zoom_box_coord[2]*scaling_factor_x),\n int(zoom_box_coord[3]*scaling_factor_y),\n linewidth=1,edgecolor='red',facecolor='none')\n new_zoom_coords = (xy[0],\n xy[1],\n int(zoom_box_coord[2]*scaling_factor_x),\n int(zoom_box_coord[3]*scaling_factor_y)\n )\n ax[0][i].add_patch(rect)\n \n # 2.2. Draw zoomed images.\n ax[1][i].imshow(subsample_image(im_i, (new_zoom_coords)))\n ax[1][i].get_xaxis().set_visible(False)\n ax[1][i].get_yaxis().set_visible(False)\n \n plt.tight_layout()\n plt.show()","def get_images_bytesize_match(self, images):\r\n cnt = 0\r\n MAX_BYTES_SIZE = 15728640\r\n good_images = []\r\n for image in images:\r\n if cnt > 30:\r\n return good_images\r\n src = self.parser.getAttribute(image, attr='src')\r\n src = self.build_image_path(src)\r\n local_image = self.get_local_image(src)\r\n if local_image:\r\n bytes = local_image.bytes\r\n if (bytes == 0 or bytes > self.images_min_bytes) \\\r\n and bytes < MAX_BYTES_SIZE:\r\n good_images.append(image)\r\n else:\r\n images.remove(image)\r\n cnt += 1\r\n return good_images if len(good_images) > 0 else None","def _filter_imgs(self, min_size=32):\n\n valid_inds = []\n for i, img_info in enumerate(self.data_infos):\n if min(img_info[\"width\"], img_info[\"height\"]) < min_size:\n continue\n if self.filter_empty_gt and len(img_info[\"ann\"][\"bboxes\"]) > 0:\n valid_inds.append(i)\n else:\n valid_inds.append(i)\n\n return valid_inds","def _filter_imgs(self, min_size=32):\r\n valid_inds = []\r\n ids_with_ann = set(_['image_id'] for _ in self.coco.anns.values())\r\n for i, img_info in enumerate(self.img_infos):\r\n if self.filter_empty_gt and self.img_ids[i] not in ids_with_ann:\r\n continue\r\n if min(img_info['width'], img_info['height']) >= min_size:\r\n valid_inds.append(i)\r\n return valid_inds","def assert_equal_shapes(numpy_arrays: list):\n\n if len(numpy_arrays) < 2:\n return\n\n shapes = np.asarray([np.shape(_arr) for _arr in numpy_arrays]).astype(float)\n mean = np.mean(shapes, axis=0)\n for i in range(len(shapes)):\n shapes[i, :] = shapes[i, :] - mean\n\n if not np.sum(np.abs(shapes)) <= 1e-5:\n raise AssertionError(\"The given volumes did not all have the same\"\n \" dimensions. Please double check the simulation\"\n f\" parameters. Called from {inspect.stack()[1].function}\")","def __len__(self):\n\n return len(self.images)","def _check_images_and_labels(self, image_dir, label_dir):\n return len(os.listdir(image_dir))==len(os.listdir(label_dir))","def is_valid(box, img):\n valid_width = box['top_left_x'] > 0 and box['bottom_right_x'] < img.shape[1]\n valid_height = box['top_left_y'] > 0 and box['bottom_right_y'] < img.shape[0]\n return valid_width and valid_height","def _filter_imgs(self, min_size=32):\n valid_inds = []\n ids_with_ann = set(_['image_id'] for _ in self.coco.anns.values())\n for i, img_info in enumerate(self.img_infos):\n if self.img_ids[i] not in ids_with_ann:\n continue\n if min(img_info['width'], img_info['height']) >= min_size:\n valid_inds.append(i)\n return valid_inds","def _filter_imgs(self, min_size=32):\n valid_inds = []\n ids_with_ann = set(_['image_id'] for _ in self.coco.anns.values())\n for i, img_info in enumerate(self.img_infos):\n if self.img_ids[i] not in ids_with_ann:\n continue\n if min(img_info['width'], img_info['height']) >= min_size:\n valid_inds.append(i)\n return valid_inds","def _filter_imgs(self, min_size=32):\n valid_inds = []\n ids_with_ann = set(_['image_id'] for _ in self.coco.anns.values())\n for i, img_info in enumerate(self.img_infos):\n if self.img_ids[i] not in ids_with_ann:\n continue\n if min(img_info['width'], img_info['height']) >= min_size:\n valid_inds.append(i)\n return valid_inds","def check_shape(self):\r\n if np.array(self.img).shape != (1536, 2048, 3):\r\n raise BadShape","def number_of_images_b_valid():\r\n counter = 0\r\n with os.scandir(os.path.join(dir_path, \"inputs\", \"type_b\")) as filepaths:\r\n for path in filepaths:\r\n extension = os.path.splitext(path)[1].lower()\r\n if extension == \".png\" or extension == \".jpg\":\r\n counter += 1\r\n if ((number_of_images_b.get() == \"\") or\r\n (counter >= int(number_of_images_b.get()))):\r\n return True\r\n else:\r\n messagebox.showwarning(\"Invalid Image Inputs\", (\r\n \"Not enough images of type b to create \"\r\n \"requested grid.\"))\r\n return False","def test_complex(self):\n image = self.design.layout.layers[0].images[2]\n assert len(image.shape_instances) == 3","def checksImages(self):\n metadata=[]\n for image in self.meta['sources']:\n with rasterio.open(image) as src:\n metaData=src.meta\n \n assert metaData['driver'] == 'GTiff', \"Driver is not supported: {0}\".format(metaData['driver'])\n assert metaData['count'] == len(self.meta['bandNames']), \"Nbands incorrect, expected: {0}, {1} provided\".format(metaData['count'],len(self.meta['bandNames']))\n \n metadata.append({'dtype': metaData['dtype'], 'driver': metaData['driver'], 'nodata': metaData['nodata'], 'nBands': metaData['count'],'crs': src.crs.to_string()})\n \n assert len(set([item['dtype'] for item in metadata])) == 1, \"Images list dtypes aren't compatibles. Expected: 1, {1} provided\".format(metaData['count'],len(set([item['dtype'] for item in metadata])))\n assert len(set([item['driver'] for item in metadata])) == 1, \"Images list drivers aren't compatibles. Expected: 1, 1 provided\".format(metaData['count'],len(set([item['driver'] for item in metadata])))\n assert len(set([item['nodata'] for item in metadata])) == 1, \"Images list nodata values aren't compatibles. Expected: 1, {1} provided\".format(metaData['count'],len(set([item['nodata'] for item in metadata])))\n assert len(set([item['nBands'] for item in metadata])) == 1, \"Images list nBands number aren't compatibles. Expected: 1, {1} provided\".format(metaData['count'],len(set([item['nBands'] for item in metadata])))\n assert len(set([item['crs'] for item in metadata])) == 1, \"Images list crs aren't compatibles. Expected: 1, {1} provided\".format(metaData['count'],len(set([item['crs'] for item in metadata]))) \n return metadata[0]","def test_correct_image_size(location):\n chunkloc = resave_to_chunks(root=location[\"dir\"],\n n_imgs=10,\n output_stem=location[\"stem\"])\n\n loaded = np.load(chunkloc)\n assert len(loaded.files) > 0\n\n first = loaded[loaded.files[0]]\n assert first.shape != ()\n assert first.shape == (520, 696)","def check_qim_dim_match(cls, qim, dim):\n return len(qim) == len(dim)","def __len__(self):\n return self.images.size(0)","def check_image_size(img_name, img_path):\n \n try:\n \n # Open image\n img = Image.open(img_name)\n \n # Determine size of image\n width, height = img.size\n \n # Check if image is square\n if (width==height):\n is_square = True\n else:\n is_square = False\n \n # Check for channels in image\n img_list = list(img.getdata())\n img_max = max(img_list)\n if (type(img_max)==int):\n is_single_channel = True\n else:\n is_single_channel = False\n \n return is_square, is_single_channel\n \n finally:\n \n # Close image\n img.close()","def check_duplicate_image_name(image_paths):\n image_names = [os.path.basename(os.path.splitext(p)[0]) for p in image_paths]\n\n num_images = len(image_names)\n\n num_unique = len(set(image_names))\n\n if num_images != num_unique:\n raise ValueError('Found %d duplicate images.' % (num_images - num_unique))\n\n logging.info('Found no duplicates in %d images.', num_images)","def __len__(self):\r\n return len(self.img_names)","def test_full_resize(self):\n number_of_pixels = 300\n destination = base_path +'/test_data/rendering_tests/resized_images/'\n source_folder = base_path + '/test_data/rendering_tests/filter_database/'\n\n\n for the_file in os.listdir(destination):\n file_path = os.path.join(destination, the_file)\n if os.path.isfile(file_path):\n os.unlink(file_path)\n\n\n self.assertEqual(0, len(os.listdir(destination)))\n rb.find_all_files(number_of_pixels,source_folder, destination)\n self.assertEqual(6, len(os.listdir(destination)))\n for the_file in os.listdir(destination):\n file_path = os.path.join(destination,the_file)\n with Image.open(file_path) as f:\n self.assertNotEqual(number_of_pixels+5, f.size[0])\n self.assertNotEqual(number_of_pixels+5, f.size[1])\n # the above checks that the size does not vary as needed\n # probably not necessary\n self.assertEqual(number_of_pixels, f.size[0])\n self.assertEqual(number_of_pixels, f.size[1])","def _check_shape(self, X):\n return all([X.shape[i] == self.train_shape[i] for i in range(2)])","def is_full(self):\r\n return self.num_checkers == self.width * self.height","def _check_size(self, img):\n absdiff = num.abs(num.subtract(img.shape, self.expected_size))\n pctdiff = num.true_divide(absdiff, self.expected_size)\n if not num.all(pctdiff <= self.size_tolerance):\n raise StandardError('image size outside form tolerance {} != {}'\n .format(img.shape, self.expected_size))","def check_dim(gr, DIM):\n l = len(gr)\n if(l != DIM):\n return False\n\n for i in range(0, DIM):\n if(len(gr[i]) != l):\n return False \n return True","def get_num_of_images(self):","def _assert_same_size(outputs, output_size):\n nest.assert_same_structure(outputs, output_size)\n flat_output_size = nest.flatten(output_size)\n flat_output = nest.flatten(outputs)\n\n for (output, size) in zip(flat_output, flat_output_size):\n if isinstance(size, tf.TensorShape):\n if output.shape == size:\n pass\n elif output[0].shape != tf.TensorShape(size):\n raise ValueError(\n \"The output size does not match the the required output_size\")","def _assert_same_size(outputs: TensorStruct, output_size: OutputSize):\n flat_output_size = nest.flatten(output_size)\n flat_output = nest.flatten(outputs)\n for output, size in zip(flat_output, flat_output_size):\n if isinstance(size, torch.Size):\n if output[0].size() != size:\n raise ValueError('The output size does not matchthe required output_size')\n elif output[0].size()[-1] != size:\n raise ValueError('The output size does not match the required output_size')","def _check_tensor_shapes(tensors):\n for tensor in tensors:\n tensor = tf.convert_to_tensor(value=tensor)\n tensor.get_shape().assert_has_rank(2)\n tensor.get_shape().assert_is_compatible_with(\n tf.convert_to_tensor(value=tensors[0]).get_shape())","def has_images(self):\n return len(self.images) > 0","def __len__(self):\n return len(self.image_paths)","def __len__(self):\n return len(self.image_paths)","def __len__(self):\n return len(self.image_paths)","def _check_sizes(self, space):\n my_dimension = self.get_total_dimension()\n other_dimension = space.get_total_dimension()\n if my_dimension != other_dimension:\n if isinstance(space, Conv2DSpace):\n if my_dimension * space.shape[0] !=\\\n other_dimension:\n raise ValueError(str(self)+\" with total dimension \" +\n str(my_dimension) +\n \" can't format a batch into \" +\n str(space) + \"because its total dimension\\\n is \" +\n str(other_dimension))","def _check_image_size(self, size):\n if size % 32 == 0:\n return (0, 0)\n else:\n imageBorder = 32 - (size % 32)\n if (imageBorder % 2) == 0:\n return (int(imageBorder / 2), int(imageBorder / 2))\n else:\n return (int(imageBorder / 2), int((imageBorder / 2) + 1))","def __len__(self):\n return len(self.image_names)","def _assert_is_batched(self, *arrays):\n shape_list = []\n for array in arrays:\n if isinstance(array, tf.Tensor):\n shape_list.append(array.shape.as_list())\n else:\n shape_list.append(np.shape(array))\n # All arrays should have at least two dimensions.\n assert all([len(shape) >= 2 for shape in shape_list])\n # All arrays should have the same batch size.\n assert len(set([shape[0] for shape in shape_list])) == 1","def check_sizes(self, show=True):\n # find pixel with common RA \n comRApix = np.where((self.coords1[0]<=np.max(self.coords2[0]))&\n (self.coords1[0]>=np.min(self.coords2[0]))\n )[0]\n \n # find pixels with common DEC \n comDECpix = np.where((self.coords1[1]<=np.max(self.coords2[1]))&\n (self.coords1[1]>=np.min(self.coords2[1]))\n )[0]\n \n print('Image 1 common pixels size: ({:}, {:})'.format(comRApix.size,\n comDECpix.size))\n \n # Corner coordinates \n minRA = np.min(self.coords1[0][comRApix])\n maxRA = np.max(self.coords1[0][comRApix])\n minDEC = np.min(self.coords1[1][comDECpix])\n maxDEC = np.max(self.coords1[1][comDECpix])\n if show:\n comFrame = plt.Rectangle(xy=(minRA, minDEC), width=maxRA-minRA,\n height=maxDEC-minDEC, hatch='\\\\', fill=True,\n color='g', alpha=.3)\n fig = plt.figure(figsize=(10,10))\n ax = fig.add_subplot(111)\n ax.add_patch(comFrame)\n ax.add_patch(self.image1.plotframe(color='r'))\n ax.add_patch(self.image2.plotframe(color='b'))\n ax.annotate('Image 1', xy=(minRA,maxDEC), color='r')\n ax.plot() \n plt.show()\n \n self.boundRA = np.array([minRA, maxRA])\n self.boundDEC = np.array([minDEC, maxDEC]) \n self.bounds1 = np.array([[comRApix[0], comRApix[-1]], \n [comDECpix[0], comDECpix[-1]]])\n \n if self.image1.get_pix_area() < self.image2.get_pix_area():\n print('Image 1 have smaller pixels than 2. \\n')\n self.pix_1_smaller = True \n else:\n print('Image 2 have smaller pixels than 1. \\n')\n self.pix_1_smaller = False","def count(self):\n \n return len(self.img_lst)","def test_valid_sizes(self):\n for size in settings.MISAGO_AVATARS_SIZES:\n self.assertEqual(clean_size(size), size)","def is_image_size_64(image):\n return image['height'] == 64 and image['width'] == 64","def canvas_size(self):\r\n width = height = 0\r\n for image in self.images:\r\n x = image.x + image.absolute_width\r\n y = image.y + image.absolute_height\r\n if width < x:\r\n width = x\r\n if height < y:\r\n height = y\r\n return round_up(width), round_up(height)","def get_all_images(self):\n self.roses.save_image()\n all_images = Images.get_all_images()\n self.assertTrue(len(all_images)<1)","def check_crop_size(size):\n type_check(size, (int, list, tuple), \"size\")\n if isinstance(size, int):\n check_value(size, (1, FLOAT_MAX_INTEGER))\n elif isinstance(size, (tuple, list)) and len(size) == 2:\n for value in size:\n check_value(value, (1, FLOAT_MAX_INTEGER))\n else:\n raise TypeError(\"Size should be a single integer or a list/tuple (h, w) of length 2.\")","def images_exist(self):\n pass","def verify_images(root_dir, root_listdir):\n counter = 0\n\n for index, image_dir in enumerate(root_listdir):\n images_listdir = os.listdir(root_dir + \"/\" + image_dir)\n list_of_images_indices = [\n image_index\n for image_index in range(3, len(images_listdir) - 1)\n if image_index % 2 == 0\n ]\n for image_ind in list_of_images_indices:\n filename = root_dir + \"/\" + image_dir + \"/\" + images_listdir[image_ind]\n try:\n im = Image.open(filename)\n im.verify()\n im.close()\n except (OSError, ValueError):\n counter += 1\n\n print(\"%d files caused error due to OSError and ValueError.\" % counter)","def have_same_shapes(array1, array2):\n return array1.shape == array2.shape","def test_test_image_dims_content(self):\n iterator = self._dataset.get_test()\n sample = next(iterator)\n image, label = sample['image'], sample['label']\n\n with self.subTest(name='DataShape'):\n self.assertTupleEqual(image.shape, (self._batch_size_test, 32, 32, 3))\n\n with self.subTest(name='DataType'):\n self.assertTrue(np.issubdtype(image.dtype, float))\n\n with self.subTest(name='DataValues'):\n # Normalized by stddev., expect nothing to fall outside 3 stddev.\n self.assertTrue((image >= -3.).all() and (image <= 3.).all())\n\n with self.subTest(name='LabelShape'):\n self.assertLen(label, self._batch_size_test)\n\n with self.subTest(name='LabelType'):\n self.assertTrue(np.issubdtype(label.dtype, int))\n\n with self.subTest(name='LabelValues'):\n self.assertTrue((label >= 0).all() and\n (label <= self._dataset.num_classes).all())","def assert_same_size(sequences):\n seq_size = len(sequences[0])\n for seq in sequences:\n if len(seq) != seq_size:\n raise SizeError","def match_size(*arrays):\n target = arrays[0].datashape\n result = []\n\n # check for bad inputs\n for a in arrays:\n ds = a.datashape.copy()\n for i in range(min(a.ndim, target.ndim)):\n if ds.dim_low[i] < target.dim_low[i] or \\\n ds.dim_high[i] > target.dim_high[i]:\n raise ValueError(\"All array domains must be a subset \"\n \"of the first array's domain\")\n\n for a in arrays:\n ds = a.datashape.copy()\n ds.dim_low = list(ds.dim_low)\n ds.dim_high = list(ds.dim_high)\n\n for i in range(min(a.ndim, target.ndim)):\n ds.dim_low[i] = target.dim_low[i]\n ds.dim_high[i] = target.dim_high[i]\n if ds != a.datashape:\n a = a.redimension(ds.schema)\n result.append(a)\n\n return tuple(result)","def _check_ensembles_are_same_size(p, q):\n if p.npdf != q.npdf:\n raise ValueError(\"Input ensembles should have the same number of distributions\")","def test_separate_ims():\n\n df1, df2 = setup()\n\n # Test 1\n im = separate_ims(df1)\n size = df1['imdims'][0]\n assert im.size == (size[0]*2, size[1])\n\n # Test 2\n im = separate_ims(df2)\n size = df2['imdims'][0]\n assert im.size == (size[0], size[1])","def __len__(self):\n return len(self.img_paths)","def getDims(img):\n n,m,k = np.shape(img) \n N,M = 0,0\n for i in range(1,n):\n if np.array_equal(img[i],img[i-1]):\n N += 1\n for j in range(1,m):\n if np.array_equal(img[:,j],img[:,j-1]):\n M += 1\n return N,M,n,m","def compare_images(img1_path, img2_path):\n img1 = Image.open(img1_path)\n img2 = Image.open(img2_path)\n try:\n diff = ImageChops.difference(img1, img2)\n except ValueError:\n return False\n return diff.getbbox() is None","def check_image_before_load(self,image_dims):\n\n if image_dims[0]*image_dims[1]*image_dims[2]*4 < self.check_available_memory():\n return True\n else:\n return False","def _checkSize(X1,X2):\n \n if len(X1) != len(X2):\n raise ValueError, 'Lists are differnt lengths'","def check_output(runtype):\n for image_name in image_names:\n for i in range(nplanes):\n compare_list_of_outputs(i,\n outputs_to_check,\n get_list_of_test_data(outputs_to_check, test_data_dir, nplanes, nchannels, added_tag, i),\n get_list_of_output_data(outputs_to_check, output_root, i)\n )","def shape(self):\n return (self.numberOfImages,) + self.imageList[0].shape","def get_image_sizes():\n widths = []\n heights = []\n\n from settings import folders_location\n for individual_folder_name in listdir(folders_location):\n individual_training_folder_path = folders_location + individual_folder_name + \"/training/\"\n\n image_paths = listdir(individual_training_folder_path)\n for image_path in image_paths:\n img = cv2.imread(individual_training_folder_path + image_path)\n\n height, width, channel = img.shape\n widths.append(width)\n heights.append(height)\n\n print(individual_training_folder_path + image_path)\n\n print(\"Min: %s, Max: %s\" % (np.min(widths), np.max(widths)))\n print(\"Average: %s\" % (np.average(widths)))\n\n return widths","def hasImages(self):\n return len(self.getImages()) > 0","def hasImages(self):\n return len(self.getImages()) > 0","def testSize (self):\r\n \r\n perpixel = bytes_per_pixel [self.bih_vals [bih_BitCount]]\r\n width = self.bih_vals [bih_Width]\r\n height = self.bih_vals [bih_Height]\r\n expected = self.bih_vals [bih_SizeImage]\r\n\r\n # Rows always have multiples of 4 bytes\r\n \r\n padding = 3 - ((perpixel * width + 3) % 4)\r\n size = (width * perpixel + padding) * height\r\n\r\n if not size == expected:\r\n print \"Calculated size = %d (<> %d)\" % (size, expected)\r\n print \"***** File size error *****\"","def _check_same_fov(*args, **kwargs):\n raise_error = kwargs.pop(\"raise_error\", False)\n for i, arg in enumerate(args):\n kwargs[f\"img_#{i}\"] = arg\n errors = []\n for (a_name, a_img), (b_name, b_img) in itertools.combinations(\n kwargs.items(), 2\n ):\n if not a_img.shape[:3] == b_img.shape[:3]:\n errors.append((a_name, b_name, \"shape\"))\n if not np.allclose(a_img.affine, b_img.affine):\n errors.append((a_name, b_name, \"affine\"))\n if len(errors) > 0 and raise_error:\n raise ValueError(\n \"Following field of view errors were detected:\\n\"\n + \"\\n\".join(\n [\n f\"- {e[0]} and {e[1]} do not have the same {e[2]}\"\n for e in errors\n ]\n )\n )\n return len(errors) == 0","def correct_batch_size_in_files(self):\n print('checking correct file sizes')\n all_ok = True\n for f in self.data_filenames:\n all_ok *= (np.load(f).shape[0] == self.batch_size)\n if not all_ok:\n break\n print(all_ok)\n return all_ok","def _check_consistency_between_imaging_extractors(self):\n return True","def check_dimensions(d_real, d_fake, d_real_logits, d_fake_logits):\n def _check_pair(a, b):\n if a != b:\n raise ValueError(\"Shape mismatch: %s vs %s.\" % (a, b))\n if len(a) != 2 or len(b) != 2:\n raise ValueError(\"Rank: expected 2, got %s and %s\" % (len(a), len(b)))\n\n if (d_real is not None) and (d_fake is not None):\n _check_pair(d_real.shape.as_list(), d_fake.shape.as_list())\n if (d_real_logits is not None) and (d_fake_logits is not None):\n _check_pair(d_real_logits.shape.as_list(), d_fake_logits.shape.as_list())\n if (d_real is not None) and (d_real_logits is not None):\n _check_pair(d_real.shape.as_list(), d_real_logits.shape.as_list())","def is_new_based_on_imgs(soup):\n\n \n \n prev_hashes = get_prev_img_hashes()\n temp_hashes = get_temp_img_hashes(soup)\n\n if len(temp_hashes.difference(prev_hashes))>0:\n print(\"new, based on images\")\n return True\n else:\n return False","def valid_image(self, image):\n valid = False\n if (isinstance(image, list) and len(image) == 11):\n valid = True\n for row in image:\n if (isinstance(row, list) and len(row) == 11):\n for pixel in row:\n if not self.valid_color(pixel):\n valid = False\n break\n else:\n valid = False\n break\n if not valid:\n _LOGGER.error(\"Invalid image data received\")\n return valid","def findWidthHeight():\n\n for f in os.listdir(\"%s/train/images/\" % args.dataset):\n if f.endswith(\".jpeg\"):\n imf = \"%s/train/images/%s\" % (args.dataset, f)\n try:\n im = Image.open(imf)\n except:\n print \"Could not open training image %s to read its size.\" %imf\n usage()\n break\n \n width = int(im.size[0])\n height = int(im.size[1])\n \n nwidth = width\n nheight = height\n if args.width:\n nwidth = args.width\n if args.height:\n nheight = args.height\n\n return width, height, nwidth, nheight, not(width == nwidth and height == nheight)","def __len__(self):\n return len(self.image_info)","def __len__(self):\n return len(self.image_info)","def test_mid_sizes(self):\n for size in settings.MISAGO_AVATARS_SIZES:\n self.assertEqual(clean_size(size - 1), size)","def test_size_check(self):\n [x1, y1, s1, g1] = self.data.diffusion_data.shape\n [x2, y2, s2, g2] = module_05.run_module(self.data).diffusion_data.shape\n self.assertEqual(x1, x2)\n self.assertEqual(y1, y2)\n self.assertEqual(s1, s2)\n self.assertEqual(g1, g2)","def _check_batch_size(self, data_list):\n if self.api_info is None:\n self.get_info() # sets the image size and other such info from server.\n MAX_BATCH_SIZE = self.api_info['max_batch_size']\n if len(data_list) > MAX_BATCH_SIZE:\n raise ApiError((\"Number of images provided in bach %d is greater than maximum allowed per \"\n \"request %d\") % (len(data_list), MAX_BATCH_SIZE))","def scan_size(self):\n max_memory = 10e9/4 # because 32-bit floats will be used\n memory = 0\n for f in self.filenames:\n img = cv2.imread(f, int(self.color))\n if img is not None:\n m = 1\n for dim in img.shape:\n m *= dim\n memory += m\n else:\n print('error opening %s' % f)\n print('size is %s bytes' % memory)\n return memory <= max_memory","def scan_size(self):\n max_memory = 10e9/4 # because 32-bit floats will be used\n memory = 0\n for f in self.filenames:\n img = cv2.imread(f, int(self.color))\n if img is not None:\n m = 1\n for dim in img.shape:\n m *= dim\n memory += m\n else:\n print('error opening %s' % f)\n print('size is %s bytes' % memory)\n return memory <= max_memory","def scan_size(self):\n max_memory = 10e9/4 # because 32-bit floats will be used\n memory = 0\n for f in self.filenames:\n img = cv2.imread(f, int(self.color))\n if img is not None:\n m = 1\n for dim in img.shape:\n m *= dim\n memory += m\n else:\n print('error opening %s' % f)\n print('size is %s bytes' % memory)\n return memory <= max_memory","def dimensions():","def check_border(pool, func, images, entries, copy_failed):\n start = time.perf_counter()\n test_results = pool.map(func, images)\n logger.info(\"%i of %i images have white border.\",\n test_results.count(True), len(test_results))\n failed = []\n # Iterate in reverse to avoid shifting\n # the indices of the objects we want to remove\n for i, passed in reversed(list(enumerate(test_results))):\n if not passed:\n del images[i]\n failed.append(entries.pop(i))\n if failed:\n # Log the names in their original order\n failed = list(reversed(failed))\n logger.info(\"Skipping %i images:\", len(failed))\n util.pprint_log([x.name for x in failed], logger.info)\n if copy_failed:\n _copy_failed(failed)\n logger.info(util.elapsed(start))\n logger.info(\"\\n\")","def check_consistent_length(arrays: Sequence[npt.ArrayLike]) -> None:\n lengths = [_num_samples(X) for X in arrays if X is not None]\n uniques = np.unique(lengths)\n if len(uniques) > 1:\n raise ValueError(\n \"Found input variables with inconsistent numbers of\" \" samples: %r\" % [int(length) for length in lengths]\n )"],"string":"[\n \"def images_are_present(file_info):\\n currentdir = os.path.join(WORKDIR, file_info['folder'])\\n if not os.path.exists(currentdir):\\n return False\\n count = len([x for x in os.listdir(currentdir) if x.endswith('.png')])\\n if count != file_info['size']:\\n print([x for x in os.listdir(currentdir) if x.endswith('.png')])\\n print('Count does not match')\\n print(count)\\n print(file_info['size'])\\n return False\\n return True\",\n \"def _get_consistent_shape(images: Iterable):\\n dim0s = []\\n dim1s = []\\n\\n for img in images:\\n dim0s.append(img.shape[0])\\n dim1s.append(img.shape[1])\\n\\n assert len(set(dim0s)) == 1 and len(set(dim1s)) == 1, 'Inconsistent shapes.'\\n\\n return dim0s[0], dim1s[0]\",\n \"def are_compatible_imgs(one_img, another_img):\\n return have_same_shapes(one_img, another_img)\",\n \"def number_of_images_valid():\\r\\n if number_of_images_a_valid() and number_of_images_b_valid():\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def image_size_exact(self, msg, img_type, height, width,\\n target=None):\\n height = int(height)\\n width = int(width)\\n sizes = self._get_sizes(msg, img_type)\\n for img in sizes:\\n if (img['width'], img['height']) == (width, height):\\n return True\\n return False\",\n \"def number_of_images_a_valid():\\r\\n counter = 0\\r\\n with os.scandir(os.path.join(dir_path, \\\"inputs\\\", \\\"type_a\\\")) as filepaths:\\r\\n for path in filepaths:\\r\\n extension = os.path.splitext(path)[1].lower()\\r\\n if extension == \\\".png\\\" or extension == \\\".jpg\\\":\\r\\n counter += 1\\r\\n if counter >= int(number_of_images_a.get()):\\r\\n return True\\r\\n else:\\r\\n messagebox.showwarning(\\\"Invalid Image Inputs\\\", (\\r\\n \\\"Not enough images of type a to create \\\"\\r\\n \\\"requested grid.\\\"))\\r\\n return False\",\n \"def check_image_size(image_folder_path, height=None, width=None):\\n total_img_list = glob.glob(os.path.join(image_folder_path, \\\"*\\\"))\\n counter = 0\\n for image in tqdm(total_img_list, desc=\\\"Checking in progress\\\"):\\n try:\\n img = cv2.imread(image)\\n\\n # Review Comments:\\n #\\n # I assume you were trying to initialize width and height\\n # if they are not defined by the caller. I have rewritten\\n # your code to do this successfully - before you were just\\n # comparing the height and width of each image with\\n # itself.\\n if height is None:\\n height = img.shape[1]\\n\\n if width is None:\\n width = img.shape[0]\\n\\n if not (height == img.shape[1] and width == img.shape[0]):\\n counter += 1\\n # Review Comments: What exception are you trying to catch here?\\n # In general, you should not have a bare except block.\\n except:\\n print(\\\"this {} is corrupted\\\".format(image))\\n continue\\n return counter\",\n \"def _autocheck_dimensions(self):\\n # W dimensions check list\\n assert len(self.W.shape) == 2, f\\\"W shape should be (N, N) but is {self.W.shape}.\\\"\\n assert self.W.shape[0] == self.W.shape[1], f\\\"W shape should be (N, N) but is {self.W.shape}.\\\"\\n\\n # Win dimensions check list\\n assert len(self.Win.shape) == 2, f\\\"Win shape should be (N, input) but is {self.Win.shape}.\\\"\\n err = f\\\"Win shape should be ({self.W.shape[1]}, input) but is {self.Win.shape}.\\\"\\n assert self.Win.shape[0] == self.W.shape[0], err\\n\\n # Wout dimensions check list\\n assert len(self.Wout.shape) == 2, f\\\"Wout shape should be (output, nb_states) but is {self.Wout.shape}.\\\"\\n nb_states = self.Win.shape[1] + self.W.shape[0] + 1 if self.use_raw_inp else self.W.shape[0] + 1\\n err = f\\\"Wout shape should be (output, {nb_states}) but is {self.Wout.shape}.\\\"\\n assert self.Wout.shape[1] == nb_states, err\\n\\n # Wfb dimensions check list\\n if self.Wfb is not None:\\n assert len(self.Wfb.shape) == 2, f\\\"Wfb shape should be (input, output) but is {self.Wfb.shape}.\\\"\\n err = f\\\"Wfb shape should be ({self.Win.shape[0]}, {self.Wout.shape[0]}) but is {self.Wfb.shape}.\\\"\\n assert (self.Win.shape[0],self.Wout.shape[0]) == self.Wfb.shape, err\",\n \"def _filter_imgs(self, min_size=32):\\n valid_inds = []\\n for i, img_info in enumerate(self.img_infos):\\n if min(img_info['width'], img_info['height']) >= min_size:\\n valid_inds.append(i)\\n return valid_inds\",\n \"def _filter_imgs(self, min_size=32):\\n valid_inds = []\\n for i, img_info in enumerate(self.img_infos):\\n if min(img_info['width'], img_info['height']) >= min_size:\\n valid_inds.append(i)\\n return valid_inds\",\n \"def ensure_images_have_the_same_properties(images, properties):\\n for prop in properties:\\n vals = np.asarray([getattr(image, prop) for image in images])\\n if not all(vals == vals[0]):\\n raise ValueError(f'To be coadded, images must all have the same {prop}. '\\n f'These images had: {[(image.id, getattr(image, prop)) for image in images]}.')\",\n \"def _check_dimensions(self, workspace_to_check):\\n for i in range(self._raw_ws.getNumDims()):\\n if self._raw_ws.getDimension(i).getNBins() != workspace_to_check._raw_ws.getDimension(i).getNBins():\\n return False\\n return True\",\n \"def check_images():\\n\\n print(f'Looking for duplicate images...')\\n\\n for image in images_in_directory:\\n duplicate = check_image_for_duplicates(image)\\n\\n if (duplicate):\\n print(f'Found {duplicate} to be a duplicate image of: {image}')\\n remove_image(duplicate)\\n pass\",\n \"def check_image_dimensions(image_paths, image_height, image_width):\\n logging.info('Using image height, width %s', str((image_height, image_width)))\\n\\n bad_images = []\\n\\n for path in image_paths:\\n logging.info('Trying to read image %s', path)\\n image = microscopeimagequality.dataset_creation.read_16_bit_greyscale(path)\\n\\n if image.shape[0] < image_height or image.shape[1] < image_width:\\n bad_images.append(path)\\n logging.info('Image %s dimension %s is too small.', path, str(image.shape))\\n\\n logging.info('Done checking images')\\n\\n logging.info('Found %d bad images.', len(bad_images))\\n\\n if bad_images:\\n raise ValueError('Found %d bad images! \\\\n %s' % (len(bad_images), '\\\\n'.join(bad_images)))\",\n \"def __len__(self):\\n return len(self.images)\",\n \"def __len__(self):\\n return len(self.images)\",\n \"def check_shapes(arrs):\\r\\n shps = [i.shape for i in arrs]\\r\\n eq = np.all(np.array([shps[0] == i for i in shps[1:]]))\\r\\n err = \\\"Arrays arr not of the same shape...\\\"\\r\\n if not eq:\\r\\n raise ValueError(\\\"{}\\\\n{}\\\".format(err, shps))\",\n \"def _filter_imgs(self, min_size=32):\\n valid_inds = []\\n for i, img_info in enumerate(self.img_infos):\\n # Filter out empty images\\n if img_info['ann']['bboxes'].shape[0] > 0:\\n if min(img_info['width'], img_info['height']) >= min_size:\\n valid_inds.append(i)\\n return valid_inds\",\n \"def n_compare(im_list, label_list, figsize=(12,8), zoom_box_coord=None,\\n zoom_box_color='red'):\\n # Error checks.\\n # =============\\n # 1. Matching lengths of image and lebal lists.\\n if len(im_list) != len(label_list):\\n raise ValueError(f\\\"\\\"\\\"List length mismatch: {len(im_list)} != {len(label_list)}. \\\"\\\"\\\"\\n \\\"\\\"\\\"Length of arguments 'im_list' and 'label_list' must be the same.\\\"\\\"\\\")\\n\\n # 2. At least 2 images are present in the input list.\\n if len(im_list) < 2:\\n raise ValueError(f\\\"Input list to argument 'im_list' must contain 2 or more items.\\\")\\n \\n # Infer values for plotting.\\n n_rows = 1 if zoom_box_coord is None else 2\\n n_cols = len(im_list)\\n scaling_factor_x = im_list[1].shape[1] / im_list[0].shape[1]\\n scaling_factor_y = im_list[1].shape[0] / im_list[0].shape[0]\\n \\n # Arrange and display images.\\n # ===========================\\n _, ax = plt.subplots(nrows=n_rows, ncols=n_cols, figsize=figsize)\\n\\n for i, im_i in enumerate(im_list):\\n if n_rows == 1:\\n # 1. If only a single row (no zoom).\\n ax[i].imshow(im_i)\\n ax[i].set_title(label_list[i])\\n ax[i].get_xaxis().set_visible(False)\\n ax[i].get_yaxis().set_visible(False)\\n else:\\n # 2. If 2 rows are to be plotted (zoom is applied).\\n ax[0][i].imshow(im_i)\\n ax[0][i].set_title(label_list[i])\\n ax[0][i].get_xaxis().set_visible(False)\\n ax[0][i].get_yaxis().set_visible(False)\\n\\n # 2.1. Handle box coordinates and scaling thereof.\\n if i == 0:\\n xy = (zoom_box_coord[0], zoom_box_coord[1])\\n rect = patches.Rectangle(xy,\\n zoom_box_coord[2],\\n zoom_box_coord[3],\\n linewidth=1,edgecolor='red',facecolor='none')\\n new_zoom_coords = (xy[0], xy[1], zoom_box_coord[2], zoom_box_coord[3])\\n else:\\n xy = (int(zoom_box_coord[0]*scaling_factor_x), int(zoom_box_coord[1]*scaling_factor_y))\\n rect = patches.Rectangle(xy,\\n int(zoom_box_coord[2]*scaling_factor_x),\\n int(zoom_box_coord[3]*scaling_factor_y),\\n linewidth=1,edgecolor='red',facecolor='none')\\n new_zoom_coords = (xy[0],\\n xy[1],\\n int(zoom_box_coord[2]*scaling_factor_x),\\n int(zoom_box_coord[3]*scaling_factor_y)\\n )\\n ax[0][i].add_patch(rect)\\n \\n # 2.2. Draw zoomed images.\\n ax[1][i].imshow(subsample_image(im_i, (new_zoom_coords)))\\n ax[1][i].get_xaxis().set_visible(False)\\n ax[1][i].get_yaxis().set_visible(False)\\n \\n plt.tight_layout()\\n plt.show()\",\n \"def get_images_bytesize_match(self, images):\\r\\n cnt = 0\\r\\n MAX_BYTES_SIZE = 15728640\\r\\n good_images = []\\r\\n for image in images:\\r\\n if cnt > 30:\\r\\n return good_images\\r\\n src = self.parser.getAttribute(image, attr='src')\\r\\n src = self.build_image_path(src)\\r\\n local_image = self.get_local_image(src)\\r\\n if local_image:\\r\\n bytes = local_image.bytes\\r\\n if (bytes == 0 or bytes > self.images_min_bytes) \\\\\\r\\n and bytes < MAX_BYTES_SIZE:\\r\\n good_images.append(image)\\r\\n else:\\r\\n images.remove(image)\\r\\n cnt += 1\\r\\n return good_images if len(good_images) > 0 else None\",\n \"def _filter_imgs(self, min_size=32):\\n\\n valid_inds = []\\n for i, img_info in enumerate(self.data_infos):\\n if min(img_info[\\\"width\\\"], img_info[\\\"height\\\"]) < min_size:\\n continue\\n if self.filter_empty_gt and len(img_info[\\\"ann\\\"][\\\"bboxes\\\"]) > 0:\\n valid_inds.append(i)\\n else:\\n valid_inds.append(i)\\n\\n return valid_inds\",\n \"def _filter_imgs(self, min_size=32):\\r\\n valid_inds = []\\r\\n ids_with_ann = set(_['image_id'] for _ in self.coco.anns.values())\\r\\n for i, img_info in enumerate(self.img_infos):\\r\\n if self.filter_empty_gt and self.img_ids[i] not in ids_with_ann:\\r\\n continue\\r\\n if min(img_info['width'], img_info['height']) >= min_size:\\r\\n valid_inds.append(i)\\r\\n return valid_inds\",\n \"def assert_equal_shapes(numpy_arrays: list):\\n\\n if len(numpy_arrays) < 2:\\n return\\n\\n shapes = np.asarray([np.shape(_arr) for _arr in numpy_arrays]).astype(float)\\n mean = np.mean(shapes, axis=0)\\n for i in range(len(shapes)):\\n shapes[i, :] = shapes[i, :] - mean\\n\\n if not np.sum(np.abs(shapes)) <= 1e-5:\\n raise AssertionError(\\\"The given volumes did not all have the same\\\"\\n \\\" dimensions. Please double check the simulation\\\"\\n f\\\" parameters. Called from {inspect.stack()[1].function}\\\")\",\n \"def __len__(self):\\n\\n return len(self.images)\",\n \"def _check_images_and_labels(self, image_dir, label_dir):\\n return len(os.listdir(image_dir))==len(os.listdir(label_dir))\",\n \"def is_valid(box, img):\\n valid_width = box['top_left_x'] > 0 and box['bottom_right_x'] < img.shape[1]\\n valid_height = box['top_left_y'] > 0 and box['bottom_right_y'] < img.shape[0]\\n return valid_width and valid_height\",\n \"def _filter_imgs(self, min_size=32):\\n valid_inds = []\\n ids_with_ann = set(_['image_id'] for _ in self.coco.anns.values())\\n for i, img_info in enumerate(self.img_infos):\\n if self.img_ids[i] not in ids_with_ann:\\n continue\\n if min(img_info['width'], img_info['height']) >= min_size:\\n valid_inds.append(i)\\n return valid_inds\",\n \"def _filter_imgs(self, min_size=32):\\n valid_inds = []\\n ids_with_ann = set(_['image_id'] for _ in self.coco.anns.values())\\n for i, img_info in enumerate(self.img_infos):\\n if self.img_ids[i] not in ids_with_ann:\\n continue\\n if min(img_info['width'], img_info['height']) >= min_size:\\n valid_inds.append(i)\\n return valid_inds\",\n \"def _filter_imgs(self, min_size=32):\\n valid_inds = []\\n ids_with_ann = set(_['image_id'] for _ in self.coco.anns.values())\\n for i, img_info in enumerate(self.img_infos):\\n if self.img_ids[i] not in ids_with_ann:\\n continue\\n if min(img_info['width'], img_info['height']) >= min_size:\\n valid_inds.append(i)\\n return valid_inds\",\n \"def check_shape(self):\\r\\n if np.array(self.img).shape != (1536, 2048, 3):\\r\\n raise BadShape\",\n \"def number_of_images_b_valid():\\r\\n counter = 0\\r\\n with os.scandir(os.path.join(dir_path, \\\"inputs\\\", \\\"type_b\\\")) as filepaths:\\r\\n for path in filepaths:\\r\\n extension = os.path.splitext(path)[1].lower()\\r\\n if extension == \\\".png\\\" or extension == \\\".jpg\\\":\\r\\n counter += 1\\r\\n if ((number_of_images_b.get() == \\\"\\\") or\\r\\n (counter >= int(number_of_images_b.get()))):\\r\\n return True\\r\\n else:\\r\\n messagebox.showwarning(\\\"Invalid Image Inputs\\\", (\\r\\n \\\"Not enough images of type b to create \\\"\\r\\n \\\"requested grid.\\\"))\\r\\n return False\",\n \"def test_complex(self):\\n image = self.design.layout.layers[0].images[2]\\n assert len(image.shape_instances) == 3\",\n \"def checksImages(self):\\n metadata=[]\\n for image in self.meta['sources']:\\n with rasterio.open(image) as src:\\n metaData=src.meta\\n \\n assert metaData['driver'] == 'GTiff', \\\"Driver is not supported: {0}\\\".format(metaData['driver'])\\n assert metaData['count'] == len(self.meta['bandNames']), \\\"Nbands incorrect, expected: {0}, {1} provided\\\".format(metaData['count'],len(self.meta['bandNames']))\\n \\n metadata.append({'dtype': metaData['dtype'], 'driver': metaData['driver'], 'nodata': metaData['nodata'], 'nBands': metaData['count'],'crs': src.crs.to_string()})\\n \\n assert len(set([item['dtype'] for item in metadata])) == 1, \\\"Images list dtypes aren't compatibles. Expected: 1, {1} provided\\\".format(metaData['count'],len(set([item['dtype'] for item in metadata])))\\n assert len(set([item['driver'] for item in metadata])) == 1, \\\"Images list drivers aren't compatibles. Expected: 1, 1 provided\\\".format(metaData['count'],len(set([item['driver'] for item in metadata])))\\n assert len(set([item['nodata'] for item in metadata])) == 1, \\\"Images list nodata values aren't compatibles. Expected: 1, {1} provided\\\".format(metaData['count'],len(set([item['nodata'] for item in metadata])))\\n assert len(set([item['nBands'] for item in metadata])) == 1, \\\"Images list nBands number aren't compatibles. Expected: 1, {1} provided\\\".format(metaData['count'],len(set([item['nBands'] for item in metadata])))\\n assert len(set([item['crs'] for item in metadata])) == 1, \\\"Images list crs aren't compatibles. Expected: 1, {1} provided\\\".format(metaData['count'],len(set([item['crs'] for item in metadata]))) \\n return metadata[0]\",\n \"def test_correct_image_size(location):\\n chunkloc = resave_to_chunks(root=location[\\\"dir\\\"],\\n n_imgs=10,\\n output_stem=location[\\\"stem\\\"])\\n\\n loaded = np.load(chunkloc)\\n assert len(loaded.files) > 0\\n\\n first = loaded[loaded.files[0]]\\n assert first.shape != ()\\n assert first.shape == (520, 696)\",\n \"def check_qim_dim_match(cls, qim, dim):\\n return len(qim) == len(dim)\",\n \"def __len__(self):\\n return self.images.size(0)\",\n \"def check_image_size(img_name, img_path):\\n \\n try:\\n \\n # Open image\\n img = Image.open(img_name)\\n \\n # Determine size of image\\n width, height = img.size\\n \\n # Check if image is square\\n if (width==height):\\n is_square = True\\n else:\\n is_square = False\\n \\n # Check for channels in image\\n img_list = list(img.getdata())\\n img_max = max(img_list)\\n if (type(img_max)==int):\\n is_single_channel = True\\n else:\\n is_single_channel = False\\n \\n return is_square, is_single_channel\\n \\n finally:\\n \\n # Close image\\n img.close()\",\n \"def check_duplicate_image_name(image_paths):\\n image_names = [os.path.basename(os.path.splitext(p)[0]) for p in image_paths]\\n\\n num_images = len(image_names)\\n\\n num_unique = len(set(image_names))\\n\\n if num_images != num_unique:\\n raise ValueError('Found %d duplicate images.' % (num_images - num_unique))\\n\\n logging.info('Found no duplicates in %d images.', num_images)\",\n \"def __len__(self):\\r\\n return len(self.img_names)\",\n \"def test_full_resize(self):\\n number_of_pixels = 300\\n destination = base_path +'/test_data/rendering_tests/resized_images/'\\n source_folder = base_path + '/test_data/rendering_tests/filter_database/'\\n\\n\\n for the_file in os.listdir(destination):\\n file_path = os.path.join(destination, the_file)\\n if os.path.isfile(file_path):\\n os.unlink(file_path)\\n\\n\\n self.assertEqual(0, len(os.listdir(destination)))\\n rb.find_all_files(number_of_pixels,source_folder, destination)\\n self.assertEqual(6, len(os.listdir(destination)))\\n for the_file in os.listdir(destination):\\n file_path = os.path.join(destination,the_file)\\n with Image.open(file_path) as f:\\n self.assertNotEqual(number_of_pixels+5, f.size[0])\\n self.assertNotEqual(number_of_pixels+5, f.size[1])\\n # the above checks that the size does not vary as needed\\n # probably not necessary\\n self.assertEqual(number_of_pixels, f.size[0])\\n self.assertEqual(number_of_pixels, f.size[1])\",\n \"def _check_shape(self, X):\\n return all([X.shape[i] == self.train_shape[i] for i in range(2)])\",\n \"def is_full(self):\\r\\n return self.num_checkers == self.width * self.height\",\n \"def _check_size(self, img):\\n absdiff = num.abs(num.subtract(img.shape, self.expected_size))\\n pctdiff = num.true_divide(absdiff, self.expected_size)\\n if not num.all(pctdiff <= self.size_tolerance):\\n raise StandardError('image size outside form tolerance {} != {}'\\n .format(img.shape, self.expected_size))\",\n \"def check_dim(gr, DIM):\\n l = len(gr)\\n if(l != DIM):\\n return False\\n\\n for i in range(0, DIM):\\n if(len(gr[i]) != l):\\n return False \\n return True\",\n \"def get_num_of_images(self):\",\n \"def _assert_same_size(outputs, output_size):\\n nest.assert_same_structure(outputs, output_size)\\n flat_output_size = nest.flatten(output_size)\\n flat_output = nest.flatten(outputs)\\n\\n for (output, size) in zip(flat_output, flat_output_size):\\n if isinstance(size, tf.TensorShape):\\n if output.shape == size:\\n pass\\n elif output[0].shape != tf.TensorShape(size):\\n raise ValueError(\\n \\\"The output size does not match the the required output_size\\\")\",\n \"def _assert_same_size(outputs: TensorStruct, output_size: OutputSize):\\n flat_output_size = nest.flatten(output_size)\\n flat_output = nest.flatten(outputs)\\n for output, size in zip(flat_output, flat_output_size):\\n if isinstance(size, torch.Size):\\n if output[0].size() != size:\\n raise ValueError('The output size does not matchthe required output_size')\\n elif output[0].size()[-1] != size:\\n raise ValueError('The output size does not match the required output_size')\",\n \"def _check_tensor_shapes(tensors):\\n for tensor in tensors:\\n tensor = tf.convert_to_tensor(value=tensor)\\n tensor.get_shape().assert_has_rank(2)\\n tensor.get_shape().assert_is_compatible_with(\\n tf.convert_to_tensor(value=tensors[0]).get_shape())\",\n \"def has_images(self):\\n return len(self.images) > 0\",\n \"def __len__(self):\\n return len(self.image_paths)\",\n \"def __len__(self):\\n return len(self.image_paths)\",\n \"def __len__(self):\\n return len(self.image_paths)\",\n \"def _check_sizes(self, space):\\n my_dimension = self.get_total_dimension()\\n other_dimension = space.get_total_dimension()\\n if my_dimension != other_dimension:\\n if isinstance(space, Conv2DSpace):\\n if my_dimension * space.shape[0] !=\\\\\\n other_dimension:\\n raise ValueError(str(self)+\\\" with total dimension \\\" +\\n str(my_dimension) +\\n \\\" can't format a batch into \\\" +\\n str(space) + \\\"because its total dimension\\\\\\n is \\\" +\\n str(other_dimension))\",\n \"def _check_image_size(self, size):\\n if size % 32 == 0:\\n return (0, 0)\\n else:\\n imageBorder = 32 - (size % 32)\\n if (imageBorder % 2) == 0:\\n return (int(imageBorder / 2), int(imageBorder / 2))\\n else:\\n return (int(imageBorder / 2), int((imageBorder / 2) + 1))\",\n \"def __len__(self):\\n return len(self.image_names)\",\n \"def _assert_is_batched(self, *arrays):\\n shape_list = []\\n for array in arrays:\\n if isinstance(array, tf.Tensor):\\n shape_list.append(array.shape.as_list())\\n else:\\n shape_list.append(np.shape(array))\\n # All arrays should have at least two dimensions.\\n assert all([len(shape) >= 2 for shape in shape_list])\\n # All arrays should have the same batch size.\\n assert len(set([shape[0] for shape in shape_list])) == 1\",\n \"def check_sizes(self, show=True):\\n # find pixel with common RA \\n comRApix = np.where((self.coords1[0]<=np.max(self.coords2[0]))&\\n (self.coords1[0]>=np.min(self.coords2[0]))\\n )[0]\\n \\n # find pixels with common DEC \\n comDECpix = np.where((self.coords1[1]<=np.max(self.coords2[1]))&\\n (self.coords1[1]>=np.min(self.coords2[1]))\\n )[0]\\n \\n print('Image 1 common pixels size: ({:}, {:})'.format(comRApix.size,\\n comDECpix.size))\\n \\n # Corner coordinates \\n minRA = np.min(self.coords1[0][comRApix])\\n maxRA = np.max(self.coords1[0][comRApix])\\n minDEC = np.min(self.coords1[1][comDECpix])\\n maxDEC = np.max(self.coords1[1][comDECpix])\\n if show:\\n comFrame = plt.Rectangle(xy=(minRA, minDEC), width=maxRA-minRA,\\n height=maxDEC-minDEC, hatch='\\\\\\\\', fill=True,\\n color='g', alpha=.3)\\n fig = plt.figure(figsize=(10,10))\\n ax = fig.add_subplot(111)\\n ax.add_patch(comFrame)\\n ax.add_patch(self.image1.plotframe(color='r'))\\n ax.add_patch(self.image2.plotframe(color='b'))\\n ax.annotate('Image 1', xy=(minRA,maxDEC), color='r')\\n ax.plot() \\n plt.show()\\n \\n self.boundRA = np.array([minRA, maxRA])\\n self.boundDEC = np.array([minDEC, maxDEC]) \\n self.bounds1 = np.array([[comRApix[0], comRApix[-1]], \\n [comDECpix[0], comDECpix[-1]]])\\n \\n if self.image1.get_pix_area() < self.image2.get_pix_area():\\n print('Image 1 have smaller pixels than 2. \\\\n')\\n self.pix_1_smaller = True \\n else:\\n print('Image 2 have smaller pixels than 1. \\\\n')\\n self.pix_1_smaller = False\",\n \"def count(self):\\n \\n return len(self.img_lst)\",\n \"def test_valid_sizes(self):\\n for size in settings.MISAGO_AVATARS_SIZES:\\n self.assertEqual(clean_size(size), size)\",\n \"def is_image_size_64(image):\\n return image['height'] == 64 and image['width'] == 64\",\n \"def canvas_size(self):\\r\\n width = height = 0\\r\\n for image in self.images:\\r\\n x = image.x + image.absolute_width\\r\\n y = image.y + image.absolute_height\\r\\n if width < x:\\r\\n width = x\\r\\n if height < y:\\r\\n height = y\\r\\n return round_up(width), round_up(height)\",\n \"def get_all_images(self):\\n self.roses.save_image()\\n all_images = Images.get_all_images()\\n self.assertTrue(len(all_images)<1)\",\n \"def check_crop_size(size):\\n type_check(size, (int, list, tuple), \\\"size\\\")\\n if isinstance(size, int):\\n check_value(size, (1, FLOAT_MAX_INTEGER))\\n elif isinstance(size, (tuple, list)) and len(size) == 2:\\n for value in size:\\n check_value(value, (1, FLOAT_MAX_INTEGER))\\n else:\\n raise TypeError(\\\"Size should be a single integer or a list/tuple (h, w) of length 2.\\\")\",\n \"def images_exist(self):\\n pass\",\n \"def verify_images(root_dir, root_listdir):\\n counter = 0\\n\\n for index, image_dir in enumerate(root_listdir):\\n images_listdir = os.listdir(root_dir + \\\"/\\\" + image_dir)\\n list_of_images_indices = [\\n image_index\\n for image_index in range(3, len(images_listdir) - 1)\\n if image_index % 2 == 0\\n ]\\n for image_ind in list_of_images_indices:\\n filename = root_dir + \\\"/\\\" + image_dir + \\\"/\\\" + images_listdir[image_ind]\\n try:\\n im = Image.open(filename)\\n im.verify()\\n im.close()\\n except (OSError, ValueError):\\n counter += 1\\n\\n print(\\\"%d files caused error due to OSError and ValueError.\\\" % counter)\",\n \"def have_same_shapes(array1, array2):\\n return array1.shape == array2.shape\",\n \"def test_test_image_dims_content(self):\\n iterator = self._dataset.get_test()\\n sample = next(iterator)\\n image, label = sample['image'], sample['label']\\n\\n with self.subTest(name='DataShape'):\\n self.assertTupleEqual(image.shape, (self._batch_size_test, 32, 32, 3))\\n\\n with self.subTest(name='DataType'):\\n self.assertTrue(np.issubdtype(image.dtype, float))\\n\\n with self.subTest(name='DataValues'):\\n # Normalized by stddev., expect nothing to fall outside 3 stddev.\\n self.assertTrue((image >= -3.).all() and (image <= 3.).all())\\n\\n with self.subTest(name='LabelShape'):\\n self.assertLen(label, self._batch_size_test)\\n\\n with self.subTest(name='LabelType'):\\n self.assertTrue(np.issubdtype(label.dtype, int))\\n\\n with self.subTest(name='LabelValues'):\\n self.assertTrue((label >= 0).all() and\\n (label <= self._dataset.num_classes).all())\",\n \"def assert_same_size(sequences):\\n seq_size = len(sequences[0])\\n for seq in sequences:\\n if len(seq) != seq_size:\\n raise SizeError\",\n \"def match_size(*arrays):\\n target = arrays[0].datashape\\n result = []\\n\\n # check for bad inputs\\n for a in arrays:\\n ds = a.datashape.copy()\\n for i in range(min(a.ndim, target.ndim)):\\n if ds.dim_low[i] < target.dim_low[i] or \\\\\\n ds.dim_high[i] > target.dim_high[i]:\\n raise ValueError(\\\"All array domains must be a subset \\\"\\n \\\"of the first array's domain\\\")\\n\\n for a in arrays:\\n ds = a.datashape.copy()\\n ds.dim_low = list(ds.dim_low)\\n ds.dim_high = list(ds.dim_high)\\n\\n for i in range(min(a.ndim, target.ndim)):\\n ds.dim_low[i] = target.dim_low[i]\\n ds.dim_high[i] = target.dim_high[i]\\n if ds != a.datashape:\\n a = a.redimension(ds.schema)\\n result.append(a)\\n\\n return tuple(result)\",\n \"def _check_ensembles_are_same_size(p, q):\\n if p.npdf != q.npdf:\\n raise ValueError(\\\"Input ensembles should have the same number of distributions\\\")\",\n \"def test_separate_ims():\\n\\n df1, df2 = setup()\\n\\n # Test 1\\n im = separate_ims(df1)\\n size = df1['imdims'][0]\\n assert im.size == (size[0]*2, size[1])\\n\\n # Test 2\\n im = separate_ims(df2)\\n size = df2['imdims'][0]\\n assert im.size == (size[0], size[1])\",\n \"def __len__(self):\\n return len(self.img_paths)\",\n \"def getDims(img):\\n n,m,k = np.shape(img) \\n N,M = 0,0\\n for i in range(1,n):\\n if np.array_equal(img[i],img[i-1]):\\n N += 1\\n for j in range(1,m):\\n if np.array_equal(img[:,j],img[:,j-1]):\\n M += 1\\n return N,M,n,m\",\n \"def compare_images(img1_path, img2_path):\\n img1 = Image.open(img1_path)\\n img2 = Image.open(img2_path)\\n try:\\n diff = ImageChops.difference(img1, img2)\\n except ValueError:\\n return False\\n return diff.getbbox() is None\",\n \"def check_image_before_load(self,image_dims):\\n\\n if image_dims[0]*image_dims[1]*image_dims[2]*4 < self.check_available_memory():\\n return True\\n else:\\n return False\",\n \"def _checkSize(X1,X2):\\n \\n if len(X1) != len(X2):\\n raise ValueError, 'Lists are differnt lengths'\",\n \"def check_output(runtype):\\n for image_name in image_names:\\n for i in range(nplanes):\\n compare_list_of_outputs(i,\\n outputs_to_check,\\n get_list_of_test_data(outputs_to_check, test_data_dir, nplanes, nchannels, added_tag, i),\\n get_list_of_output_data(outputs_to_check, output_root, i)\\n )\",\n \"def shape(self):\\n return (self.numberOfImages,) + self.imageList[0].shape\",\n \"def get_image_sizes():\\n widths = []\\n heights = []\\n\\n from settings import folders_location\\n for individual_folder_name in listdir(folders_location):\\n individual_training_folder_path = folders_location + individual_folder_name + \\\"/training/\\\"\\n\\n image_paths = listdir(individual_training_folder_path)\\n for image_path in image_paths:\\n img = cv2.imread(individual_training_folder_path + image_path)\\n\\n height, width, channel = img.shape\\n widths.append(width)\\n heights.append(height)\\n\\n print(individual_training_folder_path + image_path)\\n\\n print(\\\"Min: %s, Max: %s\\\" % (np.min(widths), np.max(widths)))\\n print(\\\"Average: %s\\\" % (np.average(widths)))\\n\\n return widths\",\n \"def hasImages(self):\\n return len(self.getImages()) > 0\",\n \"def hasImages(self):\\n return len(self.getImages()) > 0\",\n \"def testSize (self):\\r\\n \\r\\n perpixel = bytes_per_pixel [self.bih_vals [bih_BitCount]]\\r\\n width = self.bih_vals [bih_Width]\\r\\n height = self.bih_vals [bih_Height]\\r\\n expected = self.bih_vals [bih_SizeImage]\\r\\n\\r\\n # Rows always have multiples of 4 bytes\\r\\n \\r\\n padding = 3 - ((perpixel * width + 3) % 4)\\r\\n size = (width * perpixel + padding) * height\\r\\n\\r\\n if not size == expected:\\r\\n print \\\"Calculated size = %d (<> %d)\\\" % (size, expected)\\r\\n print \\\"***** File size error *****\\\"\",\n \"def _check_same_fov(*args, **kwargs):\\n raise_error = kwargs.pop(\\\"raise_error\\\", False)\\n for i, arg in enumerate(args):\\n kwargs[f\\\"img_#{i}\\\"] = arg\\n errors = []\\n for (a_name, a_img), (b_name, b_img) in itertools.combinations(\\n kwargs.items(), 2\\n ):\\n if not a_img.shape[:3] == b_img.shape[:3]:\\n errors.append((a_name, b_name, \\\"shape\\\"))\\n if not np.allclose(a_img.affine, b_img.affine):\\n errors.append((a_name, b_name, \\\"affine\\\"))\\n if len(errors) > 0 and raise_error:\\n raise ValueError(\\n \\\"Following field of view errors were detected:\\\\n\\\"\\n + \\\"\\\\n\\\".join(\\n [\\n f\\\"- {e[0]} and {e[1]} do not have the same {e[2]}\\\"\\n for e in errors\\n ]\\n )\\n )\\n return len(errors) == 0\",\n \"def correct_batch_size_in_files(self):\\n print('checking correct file sizes')\\n all_ok = True\\n for f in self.data_filenames:\\n all_ok *= (np.load(f).shape[0] == self.batch_size)\\n if not all_ok:\\n break\\n print(all_ok)\\n return all_ok\",\n \"def _check_consistency_between_imaging_extractors(self):\\n return True\",\n \"def check_dimensions(d_real, d_fake, d_real_logits, d_fake_logits):\\n def _check_pair(a, b):\\n if a != b:\\n raise ValueError(\\\"Shape mismatch: %s vs %s.\\\" % (a, b))\\n if len(a) != 2 or len(b) != 2:\\n raise ValueError(\\\"Rank: expected 2, got %s and %s\\\" % (len(a), len(b)))\\n\\n if (d_real is not None) and (d_fake is not None):\\n _check_pair(d_real.shape.as_list(), d_fake.shape.as_list())\\n if (d_real_logits is not None) and (d_fake_logits is not None):\\n _check_pair(d_real_logits.shape.as_list(), d_fake_logits.shape.as_list())\\n if (d_real is not None) and (d_real_logits is not None):\\n _check_pair(d_real.shape.as_list(), d_real_logits.shape.as_list())\",\n \"def is_new_based_on_imgs(soup):\\n\\n \\n \\n prev_hashes = get_prev_img_hashes()\\n temp_hashes = get_temp_img_hashes(soup)\\n\\n if len(temp_hashes.difference(prev_hashes))>0:\\n print(\\\"new, based on images\\\")\\n return True\\n else:\\n return False\",\n \"def valid_image(self, image):\\n valid = False\\n if (isinstance(image, list) and len(image) == 11):\\n valid = True\\n for row in image:\\n if (isinstance(row, list) and len(row) == 11):\\n for pixel in row:\\n if not self.valid_color(pixel):\\n valid = False\\n break\\n else:\\n valid = False\\n break\\n if not valid:\\n _LOGGER.error(\\\"Invalid image data received\\\")\\n return valid\",\n \"def findWidthHeight():\\n\\n for f in os.listdir(\\\"%s/train/images/\\\" % args.dataset):\\n if f.endswith(\\\".jpeg\\\"):\\n imf = \\\"%s/train/images/%s\\\" % (args.dataset, f)\\n try:\\n im = Image.open(imf)\\n except:\\n print \\\"Could not open training image %s to read its size.\\\" %imf\\n usage()\\n break\\n \\n width = int(im.size[0])\\n height = int(im.size[1])\\n \\n nwidth = width\\n nheight = height\\n if args.width:\\n nwidth = args.width\\n if args.height:\\n nheight = args.height\\n\\n return width, height, nwidth, nheight, not(width == nwidth and height == nheight)\",\n \"def __len__(self):\\n return len(self.image_info)\",\n \"def __len__(self):\\n return len(self.image_info)\",\n \"def test_mid_sizes(self):\\n for size in settings.MISAGO_AVATARS_SIZES:\\n self.assertEqual(clean_size(size - 1), size)\",\n \"def test_size_check(self):\\n [x1, y1, s1, g1] = self.data.diffusion_data.shape\\n [x2, y2, s2, g2] = module_05.run_module(self.data).diffusion_data.shape\\n self.assertEqual(x1, x2)\\n self.assertEqual(y1, y2)\\n self.assertEqual(s1, s2)\\n self.assertEqual(g1, g2)\",\n \"def _check_batch_size(self, data_list):\\n if self.api_info is None:\\n self.get_info() # sets the image size and other such info from server.\\n MAX_BATCH_SIZE = self.api_info['max_batch_size']\\n if len(data_list) > MAX_BATCH_SIZE:\\n raise ApiError((\\\"Number of images provided in bach %d is greater than maximum allowed per \\\"\\n \\\"request %d\\\") % (len(data_list), MAX_BATCH_SIZE))\",\n \"def scan_size(self):\\n max_memory = 10e9/4 # because 32-bit floats will be used\\n memory = 0\\n for f in self.filenames:\\n img = cv2.imread(f, int(self.color))\\n if img is not None:\\n m = 1\\n for dim in img.shape:\\n m *= dim\\n memory += m\\n else:\\n print('error opening %s' % f)\\n print('size is %s bytes' % memory)\\n return memory <= max_memory\",\n \"def scan_size(self):\\n max_memory = 10e9/4 # because 32-bit floats will be used\\n memory = 0\\n for f in self.filenames:\\n img = cv2.imread(f, int(self.color))\\n if img is not None:\\n m = 1\\n for dim in img.shape:\\n m *= dim\\n memory += m\\n else:\\n print('error opening %s' % f)\\n print('size is %s bytes' % memory)\\n return memory <= max_memory\",\n \"def scan_size(self):\\n max_memory = 10e9/4 # because 32-bit floats will be used\\n memory = 0\\n for f in self.filenames:\\n img = cv2.imread(f, int(self.color))\\n if img is not None:\\n m = 1\\n for dim in img.shape:\\n m *= dim\\n memory += m\\n else:\\n print('error opening %s' % f)\\n print('size is %s bytes' % memory)\\n return memory <= max_memory\",\n \"def dimensions():\",\n \"def check_border(pool, func, images, entries, copy_failed):\\n start = time.perf_counter()\\n test_results = pool.map(func, images)\\n logger.info(\\\"%i of %i images have white border.\\\",\\n test_results.count(True), len(test_results))\\n failed = []\\n # Iterate in reverse to avoid shifting\\n # the indices of the objects we want to remove\\n for i, passed in reversed(list(enumerate(test_results))):\\n if not passed:\\n del images[i]\\n failed.append(entries.pop(i))\\n if failed:\\n # Log the names in their original order\\n failed = list(reversed(failed))\\n logger.info(\\\"Skipping %i images:\\\", len(failed))\\n util.pprint_log([x.name for x in failed], logger.info)\\n if copy_failed:\\n _copy_failed(failed)\\n logger.info(util.elapsed(start))\\n logger.info(\\\"\\\\n\\\")\",\n \"def check_consistent_length(arrays: Sequence[npt.ArrayLike]) -> None:\\n lengths = [_num_samples(X) for X in arrays if X is not None]\\n uniques = np.unique(lengths)\\n if len(uniques) > 1:\\n raise ValueError(\\n \\\"Found input variables with inconsistent numbers of\\\" \\\" samples: %r\\\" % [int(length) for length in lengths]\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66642034","0.6607947","0.65018415","0.6470456","0.64090717","0.63401216","0.6332631","0.63291144","0.6313849","0.6313849","0.62913483","0.6274798","0.62315774","0.6190616","0.6132303","0.6132303","0.6086374","0.60784054","0.6073663","0.60491264","0.6013802","0.5977754","0.5968297","0.59614646","0.5955326","0.595298","0.5947664","0.5947664","0.5947664","0.5934962","0.5930257","0.58881897","0.58743364","0.5870228","0.5865093","0.5850577","0.58353615","0.58295894","0.58292246","0.5826168","0.58231425","0.5808609","0.5808343","0.5807351","0.5803726","0.58016443","0.5797772","0.5792991","0.57904416","0.57858837","0.57858837","0.57858837","0.57822603","0.57755995","0.5774412","0.57704073","0.57688147","0.57670873","0.57654274","0.5764183","0.5761486","0.5759647","0.575408","0.57523704","0.57522804","0.574026","0.5721965","0.5720845","0.5719606","0.5715905","0.570361","0.56932676","0.569114","0.56848204","0.56745785","0.5660189","0.56548697","0.56426907","0.56418246","0.5641602","0.5641602","0.56375617","0.5630976","0.5627128","0.56271166","0.56261456","0.5620279","0.5617657","0.56171244","0.56106","0.56106","0.56079566","0.560687","0.5606141","0.56056124","0.56056124","0.56056124","0.5603087","0.56015515","0.55969673"],"string":"[\n \"0.66642034\",\n \"0.6607947\",\n \"0.65018415\",\n \"0.6470456\",\n \"0.64090717\",\n \"0.63401216\",\n \"0.6332631\",\n \"0.63291144\",\n \"0.6313849\",\n \"0.6313849\",\n \"0.62913483\",\n \"0.6274798\",\n \"0.62315774\",\n \"0.6190616\",\n \"0.6132303\",\n \"0.6132303\",\n \"0.6086374\",\n \"0.60784054\",\n \"0.6073663\",\n \"0.60491264\",\n \"0.6013802\",\n \"0.5977754\",\n \"0.5968297\",\n \"0.59614646\",\n \"0.5955326\",\n \"0.595298\",\n \"0.5947664\",\n \"0.5947664\",\n \"0.5947664\",\n \"0.5934962\",\n \"0.5930257\",\n \"0.58881897\",\n \"0.58743364\",\n \"0.5870228\",\n \"0.5865093\",\n \"0.5850577\",\n \"0.58353615\",\n \"0.58295894\",\n \"0.58292246\",\n \"0.5826168\",\n \"0.58231425\",\n \"0.5808609\",\n \"0.5808343\",\n \"0.5807351\",\n \"0.5803726\",\n \"0.58016443\",\n \"0.5797772\",\n \"0.5792991\",\n \"0.57904416\",\n \"0.57858837\",\n \"0.57858837\",\n \"0.57858837\",\n \"0.57822603\",\n \"0.57755995\",\n \"0.5774412\",\n \"0.57704073\",\n \"0.57688147\",\n \"0.57670873\",\n \"0.57654274\",\n \"0.5764183\",\n \"0.5761486\",\n \"0.5759647\",\n \"0.575408\",\n \"0.57523704\",\n \"0.57522804\",\n \"0.574026\",\n \"0.5721965\",\n \"0.5720845\",\n \"0.5719606\",\n \"0.5715905\",\n \"0.570361\",\n \"0.56932676\",\n \"0.569114\",\n \"0.56848204\",\n \"0.56745785\",\n \"0.5660189\",\n \"0.56548697\",\n \"0.56426907\",\n \"0.56418246\",\n \"0.5641602\",\n \"0.5641602\",\n \"0.56375617\",\n \"0.5630976\",\n \"0.5627128\",\n \"0.56271166\",\n \"0.56261456\",\n \"0.5620279\",\n \"0.5617657\",\n \"0.56171244\",\n \"0.56106\",\n \"0.56106\",\n \"0.56079566\",\n \"0.560687\",\n \"0.5606141\",\n \"0.56056124\",\n \"0.56056124\",\n \"0.56056124\",\n \"0.5603087\",\n \"0.56015515\",\n \"0.55969673\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66137314"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":94984,"cells":{"query":{"kind":"string","value":"return a VTK image reader based on file extension"},"document":{"kind":"string","value":"def getReaderByExtension(self, ext, isRGB = 0):\n\t\tassert ext in self.extMapping, \"Extension not recognized: %s\" % ext\n\t\tmpr = self.extMapping[ext]\n\t\tprefix=\"vtk\"\n\t\t# If it's a tiff file, we use our own, extended TIFF reader\n\t\tif self.extMapping[ext] == \"TIFF\":\n\t\t\tmpr = \"ExtTIFF\"\n\t\t\tprefix=\"vtkbxd\"\n\t\tself.rdrstr = \"%s.vtk%sReader()\" % (prefix, mpr)\n\t\trdr = eval(self.rdrstr)\n\t\tif ext == \"bmp\":\n\t\t\trdr.Allow8BitBMPOn()\n\t\tif ext == \"tiff\":\n\t\t\trdr.SetFileLowerLeft(self.flipVertically)\n\t\treturn rdr"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getReadersFromFilenames(self):\n\t\tfor i in self.readers:\n\t\t\tdel i\n\t\tself.readers = []\n\n\t\tif not self.filenames:\n\t\t\traise Logging.GUIError(\"No files could be found\", \\\n\t\t\t\t\t\t\t\t\t\"For some reason, no files were listed to be imported.\")\t\t \n\t\t\t\t\t\n\t\tfiles = self.filenames\n\t\tprint \"Determining readers from \", self.filenames\n\n\t\tisRGB = 1\n\t\tself.ext = files[0].split(\".\")[-1].lower()\n\t\tdim = self.dimMapping[self.ext]\n\t\t# Initially flip the image if it's tiff, png or jpg.\n\t\t# In setVerticalFlip we negate the setting to have it set correctly.\n\t\tif self.ext.lower() in [\"png\", \"jpg\", \"jpeg\"]:\n\t\t\tself.flipVertically = True\n\t\tif self.ext in [\"tif\", \"tiff\"]:\n\t\t\treader = vtkbxd.vtkExtTIFFReader()\n\t\t\treader.SetFileName(files[0])\n\t\t\treader.UpdateInformation()\n\t\t\tif reader.GetNumberOfScalarComponents() >= 3:\n\t\t\t\tprint \"MODE IS RGB, IS AN RGB IMAGE\"\n\t\t\telse:\n\t\t\t\tprint \"MODE ISN'T RGB, THEREFORE NOT RGB\"\n\t\t\t\tisRGB = 0\n\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\trdr.SetFileName(files[0])\n\t\t\tif rdr.GetNumberOfSubFiles() > 1:\n\t\t\t\tdim = 3\n\t\t\t\t\n\t\tself.isRGB = isRGB\n\t\tself.is3D = (dim == 3)\n\t\t\n\t\tdirName = os.path.dirname(files[0])\n\t\tprint \"THERE ARE\", self.slicesPerTimepoint, \"SLICES PER TIMEPOINT\"\n\t\tself.ext = files[0].split(\".\")[-1].lower()\n\t\t\n\t\tif dim == 3:\n\t\t\ttotalFiles = len(files)\n\t\t\tfor i, file in enumerate(files):\n\t\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\t\trdr.SetFileName(file)\n\t\t\t\tself.readers.append(rdr)\n\t\t\treturn\n\t\t\t\n\t\ttotalFiles = len(files) / self.slicesPerTimepoint\n\n\t\timgAmnt = len(files)\n\t\tif totalFiles == 1:\n\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\tarr = vtk.vtkStringArray()\n\t\t\tfor fileName in files:\n\t\t\t\tarr.InsertNextValue(os.path.join(dirName, fileName))\n\t\t\trdr.SetFileNames(arr)\n\t\t\tself.readers.append(rdr)\n\t\t\treturn\n\t\t\t\n\t\tif imgAmnt > 1:\n\t\t\t# If the pattern doesn't have %, then we just use\n\t\t\t# the given filenames and allocate them to timepoints\n\t\t\t# using slicesPerTimepoint slices per timepoint\n\t\t\tntps = len(files) / self.slicesPerTimepoint\n\t\t\tfilelst = files[:]\n\t\t\t# dirn #TODO: what was this?\n\t\t\tfor tp in range(0, ntps):\n\t\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\t\tarr = vtk.vtkStringArray()\n\t\t\t\tfor i in range(0, self.slicesPerTimepoint):\n\t\t\t\t\tarr.InsertNextValue(filelst[0])\n\t\t\t\t\tfilelst = filelst[1:]\n\t\t\t\trdr.SetFileNames(arr)\n\t\t\t\trdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0, self.slicesPerTimepoint - 1)\n\t\t\t\trdr.SetDataSpacing(self.spacing)\n\t\t\t\trdr.SetDataOrigin(0, 0, 0)\n\t\t\t\tself.readers.append(rdr)\n\t\t\treturn\n\t\t\n\t\telif imgAmnt == 1:\n\t\t\t# If only one file\n\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\trdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0, self.slicesPerTimepoint - 1)\n\t\t\trdr.SetDataSpacing(self.spacing)\n\t\t\trdr.SetDataOrigin(0, 0, 0)\n\t\t\trdr.SetFileName(files[0])\n\n\t\t\tLogging.info(\"Reader = \", rdr, kw = \"io\")\n\t\t\tself.readers.append(rdr)","def _get_reader(self, filepath: str):\n file_extension = os.path.splitext(filepath)[-1]\n\n self._validate_file(filepath)\n\n if file_extension == \".ipynb\":\n return NotebookReader(filepath)\n elif file_extension in [\".py\", \".r\"]:\n return FileReader(filepath)\n else:\n raise ValueError(f\"File type {file_extension} is not supported.\")","def imread_wrapper(file):\n p = Path(file)\n if len(p.suffixes) == 2:\n series = int(Path(p.stem).stem)\n else:\n series = int(p.stem)\n return imread(file, series=series)","def _get_reader_class(basename: str) -> Type[BaseEEGReader]:\n if basename.endswith(\".h5\"):\n return RamulatorHDF5Reader\n elif basename.endswith((\".bdf\", \".mff\", \".raw\")):\n return ScalpEEGReader\n elif basename.endswith(\".npy\"):\n return NumpyEEGReader\n else:\n return SplitEEGReader","def imread(filename):\n filename = process(filename)\n ext = os.path.splitext(filename)[1]\n if ext.lower() == '.pfm':\n return load_pfm(filename)\n elif ext.lower() == '.dng':\n return load_dng(filename)\n else:\n loaded = cv2.imread(filename, flags=cv2.IMREAD_ANYDEPTH + cv2.IMREAD_COLOR)\n if loaded is None:\n raise IOError('Could not read {0}'.format(filename))\n else:\n return loaded","def ReadVTK(self, filename, element_type=None):\n\n try:\n import vtkInterface as vtki\n except IOError:\n raise IOError(\"vtkInterface is not installed. Please install it first using 'pip install vtkInterface'\")\n\n self.__reset__()\n\n vmesh = vtki.UnstructuredGrid(filename)\n flat_elements = np.copy(np.delete(vmesh.cells, vmesh.offset))\n\n if not np.all(vmesh.celltypes == vmesh.celltypes[0]):\n raise IOError(\"Cannot read VTK files with hybrid elements\")\n\n cellflag = vmesh.celltypes[0]\n\n if cellflag == 5:\n self.element_type = \"tri\"\n divider = 3\n elif cellflag == 9:\n self.element_type = \"quad\"\n divider = 4\n elif cellflag == 10:\n self.element_type = \"tet\"\n divider = 4\n elif cellflag == 12:\n self.element_type = \"hex\"\n divider = 8\n elif cellflag == 3:\n self.element_type = \"line\"\n divider = 2\n else:\n raise IOError(\"VTK element type not understood\")\n\n if element_type is not None:\n if self.element_type != element_type:\n raise ValueError(\"VTK file does not contain {} elements\".format(element_type))\n\n\n self.elements = np.ascontiguousarray(flat_elements.reshape(int(flat_elements.shape[0]/divider),divider), dtype=np.uint64)\n self.points = np.ascontiguousarray(vmesh.points, dtype=np.float64)\n self.nelem = self.elements.shape[0]\n self.nnode = self.points.shape[0]\n\n if self.points.shape[1] == 3:\n if np.allclose(self.points[:,2],0.):\n self.points = np.ascontiguousarray(self.points[:,:2])\n\n if self.element_type == \"tri\" or self.element_type == \"quad\":\n self.GetEdges()\n self.GetBoundaryEdges()\n elif self.element_type == \"tet\" or self.element_type == \"hex\":\n self.GetFaces()\n self.GetBoundaryFaces()\n self.GetBoundaryEdges()\n\n return","def read_image(path, file_format='nii.gz'):\n path = path + '.' + file_format\n if file_format == 'npy':\n image = np.load(path)\n elif file_format == 'npz':\n image = np.load(path)['arr_0']\n elif file_format in ('png', 'jpg'):\n image = np.array(imageio.imread(path))\n elif file_format == 'dcm':\n image = np.array(imageio.volread(path, 'DICOM'))\n elif file_format in ('nii', 'nii.gz'):\n image = nib.load(path).get_data()\n else:\n raise ValueError('invalid --input_type : {}'.format(file_format))\n\n return image","def get_type(ext):\n if ext.lower() in Asset.SUPPORTED_IMAGE_EXT['in']:\n return 'image'\n return 'file'","def load_image(fname):\n return load_tiff(fname)","def reader(self, idx):\n # Get the path of input image and groundtruth mask.\n input_path, gtmask_path = self.imgs[idx]\n input_img, gt_img = self.loader(input_path, gtmask_path)\n return input_img, gt_img","def readImage(self, path, tt=1):\n return cv2.imread( path, tt)","def read_image(self, filePath):\n if filePath.endswith(\".dcm\"):\n image = sitk.ReadImage(filePath)\n image = sitk.GetArrayFromImage(image).astype(\"int16\")\n image = np.expand_dims(image[0,:,:], -1)\n elif filePath.endswith(\".png\"):\n image = cv2.imread(filePath)\n image = np.array(image, dtype = \"int16\")\n elif filePath.endswith(\".mha\"):\n image = sitk.ReadImage(filePath)\n image = sitk.GetArrayFromImage(image).astype(\"int16\")\n image = np.transpose(image,(1,2,0))\n return image","def __getitem__(self, idx):\n image = Image.open(self.filenames[idx]) # PIL image\n image = self.transform(image)\n return image","def vtk_xml_reader(self):\n reader = vtk.vtkXMLStructuredGridReader()\n reader.SetFileName(self.file)\n reader.Update()\n assert isinstance(reader, vtk.vtkObject)\n return reader","def load(self, file, lazy=True):\n # individual files for each slice\n # we got one file, nice!\n \n if not lazy:\n\n if file in self.imagedict.keys():\n return self.imagedict[file]\n else:\n self.imagedict[file] = self.load(file, True)\n self.imagedict[file] *= 1\n return self.imagedict[file]\n \n else:\n \n ending = splitext(file)[-1].lower()\n if ending in ['.nii', '.hdr', '.nii.gz', '.gz']:\n if self.correct_orientation:\n vol = ni.open_image(file, verbose=False)\n self.affine = vol.get_aligned_transformation(\"RAS\")\n data = vol.aligned_volume\n else:\n f = nib.load(file)\n self.affine = f.affine\n self.pixdim = np.asarray(f.header['pixdim'][1:])\n data = f.get_data()\n return data\n # elif ending in ['.nrrd', '.nhdr']:\n # if self.correct_orientation:\n # vol = nr.open_image(file, verbose=False)\n # self.affine = vol.get_aligned_transformation(\"RAS\")\n # f = vol.aligned_volume\n # else:\n # try:\n # f, h = nrrd.read(file)\n # except:\n # print('could not read file {}'.format(file))\n # logging.getLogger('data').error('could not read file {}'.format(file))\n # raise Exception('could not read file {}'.format(file))\n # self.affine = np.eye(4)\n # return f\n # elif ending in ['.dcm']:\n # f = pydicom.dcmread(file).pixel_array\n # return f\n # elif ending in ['.mha', '.mhd']:\n # f = skio.imread(file, plugin='simpleitk')\n # self.affine = np.eye(4)\n # return f\n elif ending in ['.png', '.pgm', '.pnm']:\n data = imread(file)\n if len(data.shape) > 2:\n return np.transpose(data, [2, 0, 1])\n else:\n return data\n return imread(file)\n else:\n raise Exception('{} not known'.format(ending))","def read(infile):\n _, ext = os.path.splitext(infile)\n ext = ext.strip('.')\n return read_funcs[ext](infile)","def imread(fname):\r\n return skimage.io.imread(fname)","def _get_file_object(infilename):\n\n _, extension = os.path.splitext(infilename)\n if extension.lower() == '.spe':\n return parsers.SpeFile(infilename)\n elif extension.lower() == '.spc':\n return parsers.SpcFile(infilename)\n elif extension.lower() == '.cnf':\n return parsers.CnfFile(infilename)\n else:\n raise NotImplementedError(\n 'File type {} can not be read'.format(extension))","def viewFileByExt(filename):\n filename_ext = file_func.getFilenameExt(filename)\n if filename_ext:\n filename_ext = filename_ext.lower()\n if filename_ext in PDF_FILENAME_EXT:\n from . import pdf_func\n return pdf_func.viewPDF(pdf_filename=filename)\n\n elif filename_ext in IMG_FILENAME_EXT:\n from . import img_func\n return img_func.viewImage(img_filename=filename)\n\n elif filename_ext in OFFICE_FILENAME_EXT:\n from . import office_func\n return office_func.openInLibreOffice(filename)\n else:\n log_func.warning(u'Not supported view file type <%s>' % filename_ext)\n else:\n log_func.warning(u'Not defined ext of filename <%s>' % filename)\n return False","def iread(filename, *args, verbose=True, **kwargs):\n\n # determine if file is valid:\n # assert isinstance(filename, str), 'filename must be a string'\n\n\n # TODO read options for image\n # opt = {\n # 'uint8': False,\n # 'single': False,\n # 'double': False,\n # 'grey': False,\n # 'grey_709': False,\n # 'gamma': 'sRGB',\n # 'reduce': 1.0,\n # 'roi': None\n # }\n\n if isinstance(filename, str) and (filename.startswith(\"http://\") or filename.startswith(\"https://\")):\n # reading from a URL\n\n resp = urllib.request.urlopen(filename)\n array = np.asarray(bytearray(resp.read()), dtype=\"uint8\")\n image = cv.imdecode(array, -1)\n print(image.shape)\n return (image, filename)\n\n elif isinstance(filename, (str, Path)):\n # reading from a file\n\n path = Path(filename).expanduser()\n\n if any([c in \"?*\" for c in str(path)]):\n # contains wildcard characters, glob it\n # recurse and return a list\n # https://stackoverflow.com/questions/51108256/how-to-take-a-pathname-string-with-wildcards-and-resolve-the-glob-with-pathlib\n \n parts = path.parts[1:] if path.is_absolute() else path.parts\n p = Path(path.root).glob(str(Path(\"\").joinpath(*parts)))\n pathlist = list(p)\n\n if len(pathlist) == 0 and not path.is_absolute():\n # look in the toolbox image folder\n path = Path(__file__).parent / \"images\" / path\n parts = path.parts[1:] if path.is_absolute() else path.parts\n p = Path(path.root).glob(str(Path(\"\").joinpath(*parts)))\n pathlist = list(p)\n \n if len(pathlist) == 0:\n raise ValueError(\"can't expand wildcard\")\n\n imlist = []\n pathlist.sort()\n for p in pathlist:\n imlist.append(iread(p, **kwargs))\n return imlist\n\n else:\n # read single file\n\n if not path.exists():\n if path.is_absolute():\n raise ValueError(f\"file {filename} does not exist\")\n # file doesn't exist\n # see if it matches the supplied images\n path = Path(__file__).parent / \"images\" / path\n\n if not path.exists():\n raise ValueError(f\"file {filename} does not exist, and not found in supplied images\")\n\n # read the image\n # TODO not sure the following will work on Windows\n im = cv.imread(path.as_posix(), **kwargs) # default read-in as BGR\n\n if im is None:\n # TODO check ValueError\n raise ValueError(f\"Could not read {filename}\")\n\n return (im, str(path))\n\n elif islistof(filename, (str, Path)):\n # list of filenames or URLs\n # assume none of these are wildcards, TODO should check\n out = []\n for file in filename:\n out.append(iread(file, *args))\n return out\n else:\n raise ValueError(filename, 'invalid filename')","def img_in(filename):\n temp_img = Image.open(filename)\n img = np.array(temp_img)\n name = filename.split('.')[-2]\n return name, img","def _read_file(self):\n extension = self.path.split('.')[-1]\n if extension!='avi':\n raise Exception(\"Invalid Format\")\n\n return cv2.VideoCapture(self.path)","def MFileReader(fvcom, *args, **kwargs):\n\n if isinstance(fvcom, str):\n FVCOM = FileReader(fvcom, *args, **kwargs)\n else:\n for file in fvcom:\n if file == fvcom[0]:\n FVCOM = FileReader(file, *args, **kwargs)\n else:\n FVCOM += FileReader(file, *args, **kwargs)\n\n return FVCOM","def read_image_file(file_name):\n return torch.from_numpy(np.asarray(Image.open(file_name).convert('L')))","def load(cls,filename,format=None,**kwargs):\n\n\t\tif format is None:\n\t\t\t\n\t\t\textension = filename.split(\".\")[-1]\n\t\t\tif extension in [\"fit\",\"fits\"]:\n\t\t\t\tformat=\"fits\"\n\t\t\telif extension in [\"npy\",\"npz\"]:\n\t\t\t\tformat=\"npz\"\n\t\t\telse:\n\t\t\t\traise IOError(\"File format not recognized from extension '{0}', please specify it manually\".format(extension))\n\n\t\tif format==\"fits\":\n\t\t\treturn loadFITS(cls,filename)\n\t\telif format==\"npz\":\n\t\t\treturn loadNPZ(cls,filename)\n\t\telse:\n\t\t\tangle,data = format(filename,**kwargs)\n\t\t\treturn cls(data,angle)","def get_input(self, idx):\r\n img_filename = self.root / \"images\" / self._image_array[idx]\r\n x = Image.open(img_filename)\r\n return x","def inferReader(filePath):\n for reg, reader in six.iteritems(REGEXES):\n match = re.match(reg, filePath)\n if match and match.group() == filePath:\n debug('Inferred reader for {}: {}'\n .format(filePath, reader.__name__))\n return reader\n raise SerpentToolsException(\n 'Failed to infer filetype and thus accurate reader from'\n 'file path {}'.format(filePath)\n )","def open_image(self, filename):\n return np.array(self.ds['test'].load_image(filename))","def reader(name, version=None, mimetype=None):\n\treturn _data_processor('read', name, version, mimetype)","def _read_ext(cls, hdulist, extname, **kwargs):\n try:\n if cls == Table:\n # use Table.read method to ensure extra header keywords are loaded\n # as metadata\n obj = Table.read(hdulist, hdu=extname)\n obj = Table(obj, **kwargs)\n else:\n obj = cls(hdulist[extname].data, **kwargs)\n except Exception as e:\n raise IOError('%s: Impossible to open extension %s as a %s\\n%s' % (\n os.path.basename(hdulist.filename()), extname, cls.__name__, e))\n return obj","def loadVtk(self, fname):\n\n reader = vtk.vtkUnstructuredGridReader()\n reader.SetFileName(filename)\n reader.Update()\n self._vtk = reader.GetOutput()","def openFile(path_name):\n if os.path.isdir(path_name):\n reader = sitk.ImageSeriesReader()\n dicom_names = reader.GetGDCMSeriesFileNames(path_name)\n reader.SetFileNames(dicom_names)\n image_object = reader.Execute()\n \n elif os.path.isfile(path_name):\n image_object = sitk.ReadImage(path_name)\n\n else:\n print(\"Path name wrong.\")\n return None\n\n return image_object","def image(fname):\n return cv2.imread(fname)","def imagefile(self):\n if self.__filetype==\"flatWarp\" :\n ext = \".fw\"\n elif self.__filetype==\"camWarp\" :\n ext = \".camWarp\"\n elif self.__filetype==\"raw\" :\n ext = \".Data.dat\"\n else :\n raise ValueError(f\"requested file type {self.__filetype} not recognized\")\n\n return self.__imagefolder/self.file.replace(\".im3\", ext)","def get_reader(fn):\n if is_bed(fn):\n return BedReader(fn)\n elif is_vcf(fn):\n return VcfReader(fn)\n else:\n raise ValueError(\"Could not get reader for %s\" % fn)","def load_file(self):\n extensions = DataReader().get_supported_extensions_as_string()\n file_name, _ = QFileDialog.getOpenFileName(self, \"Open data set\", \"\",\n \"Images (\" + extensions + \")\")\n if not file_name:\n return\n\n self.render_widget.load_file(file_name)\n self.switch_to_simple()","def get_split(split_name, dataset_dir, file_pattern=None, reader=None):\n if split_name not in SPLITS_TO_SIZES:\n raise ValueError('split name %s was not recognized.' % split_name)\n \n if not file_pattern:\n file_pattern = FILE_PATTERN\n file_pattern = os.path.join(dataset_dir, file_pattern % split_name)\n \n # Allowing None in the signature so that dataset_factory can use the default.\n if reader is None:\n reader = tf.TFRecordReader\n# #文件名格式\n# if file_pattern is None:\n# file_pattern = _get_output_filename('tfrecords','voc_2007_train')#need fix your filename\n# print(file_pattern)\n \n # 适配器1：将example反序列化成存储之前的格式。由tf完成\n keys_to_features = {\n 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''),\n 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpg'),\n 'image/height': tf.FixedLenFeature([1], tf.int64),\n 'image/width': tf.FixedLenFeature([1], tf.int64),\n 'image/channels': tf.FixedLenFeature([1], tf.int64),\n 'image/shape': tf.FixedLenFeature([3], tf.int64),\n 'image/object/bbox/xmin': tf.VarLenFeature(dtype=tf.float32),\n 'image/object/bbox/ymin': tf.VarLenFeature(dtype=tf.float32),\n 'image/object/bbox/xmax': tf.VarLenFeature(dtype=tf.float32),\n 'image/object/bbox/ymax': tf.VarLenFeature(dtype=tf.float32),\n 'image/object/bbox/label': tf.VarLenFeature(dtype=tf.int64),\n 'image/object/bbox/difficult': tf.VarLenFeature(dtype=tf.int64),\n 'image/object/bbox/truncated': tf.VarLenFeature(dtype=tf.int64),\n }\n \n #适配器2：将反序列化的数据组装成更高级的格式。由slim完成\n items_to_handlers = {\n 'image': slim.tfexample_decoder.Image('image/encoded', 'image/format'),\n 'shape': slim.tfexample_decoder.Tensor('image/shape'),\n 'object/bbox': slim.tfexample_decoder.BoundingBox(\n ['ymin', 'xmin', 'ymax', 'xmax'], 'image/object/bbox/'),\n 'object/label': slim.tfexample_decoder.Tensor('image/object/bbox/label'),\n 'object/difficult': slim.tfexample_decoder.Tensor('image/object/bbox/difficult'),\n 'object/truncated': slim.tfexample_decoder.Tensor('image/object/bbox/truncated'),\n }\n # 解码器\n decoder = slim.tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers)\n \n # dataset对象定义了数据集的文件位置，解码方式等元信息\n dataset = slim.dataset.Dataset(\n data_sources=file_pattern,\n reader=reader,\n num_samples = SPLITS_TO_SIZES['test'], # 手动生成了三个文件， 每个文件里只包含一个example\n decoder=decoder,\n items_to_descriptions = ITEMS_TO_DESCRIPTIONS,\n num_classes=NUM_CLASSES)\n return dataset","def load_image(path: str):\n if path.endswith('.npy'):\n return np.load(path)\n if path.endswith(('.nii', '.nii.gz', '.hdr', '.img')):\n import nibabel as nib\n return nib.load(path).get_data()\n if path.endswith('.tif'):\n from PIL import Image\n with Image.open(path) as image:\n return np.asarray(image)\n\n raise ValueError(f\"Couldn't read image from path: {path}.\\n\"\n \"Unknown file extension.\")","def loaddata(path):\n if path.endswith(\".tiff\") or path.endswith(\".tif\"):\n try:\n from vigra.impex import readVolume\n except ImportError:\n raise ImportError(\"Vigra is needed to read/write TIFF volumes, but could not be imported.\")\n\n volume = readVolume(path)\n return volume\n\n elif path.endswith(\".h5\"):\n try:\n from Antipasti.netdatautils import fromh5\n except ImportError:\n raise ImportError(\"h5py is needed to read/write HDF5 volumes, but could not be imported.\")\n\n volume = fromh5(path)\n return volume\n\n else:\n raise NotImplementedError(\"Can't load: unsupported format. Supported formats are .tiff and .h5\")","def __getitem__(self, idx):\n ImageFile.LOAD_TRUNCATED_IMAGES = True\n image = Image.open(self.filenames[idx]) # PIL image\n width, height = image.size\n if width<IMAGE_SIZE or height<IMAGE_SIZE:\n image = image.resize((IMAGE_SIZE+50, IMAGE_SIZE+50))\n \n image = image.convert('RGB')\n tensor = self.transform(image)\n sample = (tensor, self.labels[idx])\n return sample","def _load_image(self, index: int) -> Tensor:\n path = self.files[index][\"image\"]\n with rasterio.open(path) as f:\n array = f.read()\n tensor = torch.from_numpy(array).float()\n return tensor","def parse_extension(filepath):\n extension = os.path.splitext(filepath)[1][1:]\n\n extensions_dict = {\"netcdf\": ['nc'],\n \"mitiff\": ['mitiff'],\n \"geotiff\": ['gtiff', 'tiff', 'tif']}\n\n driver = None\n\n for key in extensions_dict:\n if extension in extensions_dict[key]:\n driver = key \n\n if driver is not None:\n return driver\n else:\n raise Exception(\"Unknown file extension, cannot guess file format\")","def __getitem__(self, idx):\n label, path = self.pathList[idx]\n file_list = os.listdir(path)\n # parse the images in the folder\n for pt_file in file_list:\n file_path = path + pt_file\n extension = os.path.splitext(file_path)[1]\n\n # choose only the file that has the tensor weights\n if extension == '.pt':\n tensor = torch.load(file_path) # size Nx20x2 because the shape is made of 20 (x,y) tuples\n \n # Change type Int to type Float\n tensor = tensor.type(torch.FloatTensor) # On cpu for now\n\n # normalization of the coordinates\n #tensor[:,:,0] /= 300 # x\n #tensor[:,:,1] /= 150 # y\n\n tensor = tensor.view(tensor.size()[0], 40) # resize to Nx40\n\n return tensor, label","def __ext_from_image_stream(stream):\n ext_map = {'GIF': '.gif', 'JPEG': '.jpg', 'PNG': '.png',\n 'TIFF': '.tiff', 'WMF': '.wmf'}\n stream.seek(0)\n format = PIL_Image.open(stream).format\n if format not in ext_map:\n tmpl = \"unsupported image format, expected one of: %s, got '%s'\"\n raise ValueError(tmpl % (ext_map.keys(), format))\n return ext_map[format]","def get_from_file(self, filename):\n print \"loading from file...\"\n return cv2.imread(filename)","def retrieveImageInfo(self, filename):\t\t \n\t\tassert filename, \"Filename must be defined\"\n\t\tassert os.path.exists(filename), \"File that we're retrieving information \\\n\t\t\t\t\t\t\t\t\t\tfrom (%s) needs to exist, but doesn't.\" % filename\n\t\tself.ext = filename.split(\".\")[-1].lower()\n\t\trdr = self.getReaderByExtension(self.ext)\n\t\t\n\t\tif self.ext == \"bmp\":\n\t\t\trdr.Allow8BitBMPOn()\n\t\trdr.SetFileName(filename)\n\t\tif rdr.IsA(\"vtkExtTIFFReader\"):\n\t\t\trdr.UpdateInformation()\n\t\t\tif rdr.GetNumberOfScalarComponents() == 1:\n\t\t\t\trdr.RawModeOn()\n\n\t\tdata = rdr.GetOutput()\n\t\tdata.Update()\n\t\tself.numberOfComponents = data.GetNumberOfScalarComponents()\n\n\t\tif not self.ctf:\n\t\t\tbd = self.getDataBitDepth(data)\n\t\t\tself.ctf = vtk.vtkColorTransferFunction()\n\t\t\tif bd == 8 or bd == 12:\n\t\t\t\tself.ctf.AddRGBPoint(0, 0, 0, 0)\n\t\t\t\tself.ctf.AddRGBPoint((2 ** bd) - 1, 0, 1, 0)\n\t\t\telse:\n\t\t\t\trange = data.GetScalarRange()\n\t\t\t\tself.ctf.AddRGBPoint(range[0], 0, 0, 0)\n\t\t\t\tself.ctf.AddRGBPoint(range[1], 0, 1, 0)\n\t\t\t\n\t\tself.x, self.y, z = data.GetDimensions()\n\t\tself.dimensions = (self.x, self.y, self.slicesPerTimepoint)\n\t\tif z > 1:\n\t\t\tself.slicesPerTimepoint = z\n\t\t\tself.z = z\n\t\t\tself.dimensions = (self.x, self.y, self.slicesPerTimepoint)\n\t\t\tlib.messenger.send(self, \"update_dimensions\")\n\t\tself.originalDimensions = self.dimensions","def create(path: Union[Path, str]):\n if isinstance(path, str):\n path = Path(path)\n \n ext = path.suffix.lower()\n if ext == \".hdr\":\n reader = RadianceHDRFormat.read\n elif ext == \".exr\":\n reader = OpenEXRFormat.read\n elif ext == \".pfm\":\n reader = PFMFormat.read\n else:\n # assuming the image is LDR\n def pil_reader(path: Union[Path, str]) -> np.ndarray:\n # open path as file to avoid ResourceWarning (https://github.com/python-pillow/Pillow/issues/835)\n with open(path, 'rb') as f:\n img = Image.open(f)\n img = np.asarray(img.convert(\"RGB\"))\n if img.dtype.startswith(\"uint\") or img.dtype.startswith(\"int\"):\n info = np.iinfo(img.dtype)\n elif img.dtype.startswith(\"float\"):\n info = np.finfo(img.dtype)\n else:\n raise TypeError()\n\n min_ = float(info.min)\n max_ = float(info.max)\n return min_max_normalization(img.astype(np.float64), min_, max_) \n reader = pil_reader\n return reader","def read_array(self, filename):\n extension = filename.split('.')[-1] # Get file extension\n if extension == 'mat':\n array = sci.loadmat(filename)\n elif extension == 'npy':\n array = np.load(filename)\n else:\n print('Error!!! Unrecognised file type for read_array()')\n array = None\n return array","def nircam_image_reader(file_name):\n\n hdulist = fits.open(file_name)\n data = Data(label='NIRCam Image')\n data.header = hdulist[0].header\n wcs = WCS(hdulist[0].header)\n\n # drop the last axis since the cube will be split\n data.coords = coordinates_from_wcs(wcs.sub(2))\n data.add_component(hdulist[0].data[0], 'Flux')\n data.add_component(hdulist[0].data[1], 'Uncertainty')\n\n return data","def load(self,filename):\n basename = os.path.basename(filename)\n self.name, ext = os.path.splitext(basename)\n if ext == '.xml':\n self.load_xml(filename)\n elif ext == '.tsv':\n self.load_tsv_fast(filename)\n elif ext == '.tsvs':\n self.load_tsv(filename)\n else:\n print 'Error: only .xml and .tsv files are supported'","def vF3d_VTK(field,name,VTKformat): \n if VTKformat == 'vtu':\n vf3d_vtu(field,name)\n elif VTKformat == None:\n print 'Please select a VTK format'\n else:\n print 'The selected format has not been developed yet'\n return #nothing, since functions output the written VTK file","def get_loader(csv_file, img_dir, image_size, batch_size, mode='val', dataset='vg'):\n\n if dataset == 'VG':\n \n transform = transforms.Compose([\n transforms.Resize(image_size),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n\n dataset = GeneratedVGDataset(csv_file, img_dir, transform)\n else:\n \traise Exception(\"currently only VG generated images dataset is provided \")\n\n shuffle = True if mode == 'train' else False\n \n data_loader = DataLoader(dataset=dataset, batch_size=batch_size, shuffle=shuffle, num_workers=4)\n\n return data_loader","def load_volume(name, nx, ny, nz):\n\n # load raw volume into memory\n img = np.fromfile(name, dtype=np.float32)\n img = np.reshape(img, (ny, nx, nz))\n\n return img.transpose(0, 2, 1)","def __getitem__(self, t):\n collection = {}\n\n # read raw data and unpack (if necessary)\n for typ in self.files.keys():\n scan_data = None\n if typ == \"label\":\n scan_data = np.fromfile(self.files[typ][t], dtype=np.uint16)\n else:\n scan_data = unpack(np.fromfile(self.files[typ][t], dtype=np.uint8))\n\n # turn in actual voxel grid representation.\n collection[typ] = scan_data.reshape(VOXEL_DIMS)\n\n return self.filenames[t], collection","def imgRead(filename: str, representation: int) -> np.ndarray:\r\n if representation==LOAD_GRAY_SCALE:\r\n img = cv2.imread(filename,0)\r\n else:\r\n img = cv2.imread(filename)\r\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\r\n return img.astype('uint8')","def _open_image(self, path):\n return cv.imread(path, 1)\n # .astype(float)","def get_split(split_name, dataset_dir, file_pattern=None, reader=None):\n\tif split_name not in SPLITS_TO_SIZES and split_name[:-2] not in SPLITS_TO_SIZES:\n\t\traise ValueError('split name %s was not recognized.' % split_name)\n\n\tif not file_pattern:\n\t\tfile_pattern = _FILE_PATTERN\n\tfile_pattern = os.path.join(dataset_dir, file_pattern % split_name)\n\t#Allowing None in the signature so that the dataset_factory can use the default\n\tif reader is None:\n\t\treader = tf.TFRecordReader\n\n\tkeys_to_features = {\n\t\t'image/encoded': tf.FixedLenFeature(\n\t\t\t(), tf.string, default_value=''),\n\t\t'image/format': tf.FixedLenFeature(\n\t\t\t(), tf.string, default_value='jpeg'),\n\t\t'image/class/label': tf.FixedLenFeature(\n\t\t\t[], tf.int64, default_value=tf.zeros([], dtype=tf.int64)),\n\t}\n\titems_to_handlers = {\n\t\t'image': slim.tfexample_decoder.Image(),\n\t\t'label': slim.tfexample_decoder.Tensor('image/class/label'),\n\t}\n\n\tdecoder = slim.tfexample_decoder.TFExampleDecoder(\n\t\tkeys_to_features, items_to_handlers)\n\n\tlabels_to_names = None\n\tif dataset_utils.has_labels(dataset_dir):\n\t\tlabels_to_names=dataset_utils.read_label_file(dataset_dir)\n\t\n\tif split_name in SPLITS_TO_SIZES:\n\t\tnum_samples = SPLITS_TO_SIZES[split_name]\n\telif split_name[:-2] in SPLITS_TO_SIZES:\n\t\tnum_samples = SPLITS_TO_SIZES[split_name[:-2]]\n\n\treturn slim.dataset.Dataset(data_sources=file_pattern,\n\t\treader=reader,\n\t\tdecoder=decoder,\n\t\tnum_samples=num_samples,\n\t\titems_to_descriptions=_ITEMS_TO_DESCRIPTIONS,\n\t\tnum_classes=_NUM_CLASSES,\n\t\tlabels_to_names=labels_to_names)","def file_reader(image_file, label_file):\n\n image = im.imread(image_file)\n\n with open(label_file, \"r\") as file:\n label = float(file.read())\n\n return image, label","def get_itk_image(path):\n\n reader = itk.ImageFileReader()\n reader.SetFileName(path)\n\n image = reader.Execute()\n\n return image","def get_split(split_name, dataset_dir, file_pattern=None, reader=None):\n\tif split_name not in _SPLITS_TO_SIZES:\n\t\traise ValueError(\"split name %s was not recognized.\" % split_name)\n\tif not file_pattern:\n\t\tfile_pattern = _FILE_PATTERN\n\tfile_pattern = os.path.join(dataset_dir, file_pattern % split_name)\n\tif reader is None:\n\t\treader = tf.TFRecordReader\n\tkeys_to_features = {\"image/encoded\": tf.FixedLenFeature((), tf.string, default_value=\"\"), \"image/format\": tf.FixedLenFeature((), tf.string, default_value=\"png\"), \"image/class/label\": tf.FixedLenFeature([1], tf.int64, default_value=tf.zeros([1], dtype=tf.int64))}\n\titems_to_handlers = {\"image\": slim.tfexample_decoder.Image(shape=[32, 32, 3], channels=3), \"label\": slim.tfexample_decoder.Tensor(\"image/class/label\", shape=[])}\n\tdecoder = slim.tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers)\n\tlabels_to_names = None\n\tif dataset_utils.has_labels(dataset_dir):\n\t\tlabels_to_names = dataset_utils.read_label_file(dataset_dir)\n\treturn slim.dataset.Dataset(data_sources=file_pattern, reader=reader, decoder=decoder, num_samples=_SPLITS_TO_SIZES[split_name], num_classes=_NUM_CLASSES, items_to_descriptions=_ITEMS_TO_DESCRIPTIONS, labels_to_names=labels_to_names)","def import_grid(file_name):\n\n return FileReader(file_name=file_name).grid","def LoadMetadata(filename):\r\n## print filename\r\n globbed=glob.glob(os.path.join(os.path.dirname(filename),'*.zvi'))\r\n if globbed:\r\n return LoadZVIMetaData(globbed[0])\r\n globbed=glob.glob(os.path.join(os.path.dirname(filename),'*.xml'))\r\n if globbed:\r\n return LoadAxioVisionXMLMetaData(globbed[0])\r\n globbed=glob.glob(os.path.join(os.path.dirname(filename),'metadata.txt'))\r\n if globbed:\r\n return LoadMMMetaData(globbed[0])\r\n return None\r\n #no further valid options, crash horribly\r","def load_faces(path, ext=\".pgm\"):\n \n #\n # You code here\n #\n \n images = []\n img_shape = (0, 0)\n\n for root, dirs, files in os.walk(path):\n for file in files:\n if ext in file: # check if file is of pgm-type\n img_path = os.path.join(root, file)\n img = plt.imread(img_path) # Read the image\n img_shape = img.shape\n img = img.flatten() # Transform 2D image into vector M = height x width\n images.append(img)\n\n img_array = np.asarray(images) \n\n return img_array, img_shape","def get_input(path):\n img = imread(path)\n return img","def driver_from_file(input_file: str, quick: bool = True) -> str:\n input_file = MPath.from_inp(input_file)\n\n # mapchete files can immediately be returned:\n if input_file.suffix == \".mapchete\":\n return \"Mapchete\"\n\n # use the most common file extensions to quickly determine input driver for file:\n if quick:\n try:\n return driver_from_extension(input_file.suffix)\n except ValueError:\n pass\n\n # brute force by trying to open file with rasterio and fiona:\n try:\n logger.debug(\"try to open %s with rasterio...\", input_file)\n with rasterio_open(input_file): # pragma: no cover\n return \"raster_file\"\n except Exception as rio_exception:\n try:\n logger.debug(\"try to open %s with fiona...\", input_file)\n with fiona_open(input_file): # pragma: no cover\n return \"vector_file\"\n except Exception as fio_exception:\n if input_file.exists():\n logger.exception(f\"fiona error: {fio_exception}\")\n logger.exception(f\"rasterio error: {rio_exception}\")\n raise MapcheteDriverError(\n \"%s has an unknown file extension and could not be opened by neither \"\n \"rasterio nor fiona.\" % input_file\n )\n else:\n raise FileNotFoundError(\"%s does not exist\" % input_file)","def read(dataset = \"training\", path = \".\"):\n\n if dataset is \"training\":\n fname_img = os.path.join(path, 'train-images.idx3-ubyte')\n fname_lbl = os.path.join(path, 'train-labels.idx1-ubyte')\n elif dataset is \"testing\":\n fname_img = os.path.join(path, 't10k-images.idx3-ubyte')\n fname_lbl = os.path.join(path, 't10k-labels.idx1-ubyte')\n else:\n raise ValueError(\"dataset must be 'testing' or 'training'\")\n\n # Load everything in some numpy arrays\n with open(fname_lbl, 'rb') as flbl:\n magic, num = struct.unpack(\">II\", flbl.read(8))\n lbl = np.fromfile(flbl, dtype=np.int8)\n\n with open(fname_img, 'rb') as fimg:\n magic, num, rows, cols = struct.unpack(\">IIII\", fimg.read(16))\n img = np.fromfile(fimg, dtype=np.uint8).reshape(len(lbl), rows, cols)\n\n get_img = lambda idx: (lbl[idx], img[idx])\n\n # Create an iterator which returns each image in turn\n for i in range(len(lbl)):\n yield get_img(i)","def read_image(filename, representation):\n img = imread(filename)\n img = int2float(img)\n if representation == GS_REP:\n img = rgb2gray(img)\n return img","def file_type(filepath):\n imexts = ['.png', '.bmp', '.jpg', 'jpeg']\n textexts = ['.csv', '.txt']\n if filepath.endswith('.hdf5') or filepath.endswith('.h5'):\n return 'hdf5'\n if any([filepath.endswith(ext) for ext in textexts]):\n return 'delim'\n if filepath.endswith('.grm.raw'):\n return 'grm.raw'\n if filepath.endswith('.npy'):\n return 'npy'\n if _is_bed(filepath):\n return 'bed'\n if _is_gen(filepath):\n return 'gen'\n if any([filepath.endswith(ext) for ext in imexts]):\n return 'image'\n return 'unknown'","def read(filename, ext=None, extver=None, columns=None, rows=None,\n header=False, case_sensitive=False, upper=False, lower=False,\n vstorage='fixed', verbose=False, trim_strings=False, **keys):\n\n if keys:\n import warnings\n warnings.warn(\n \"The keyword arguments '%s' are being ignored! This warning \"\n \"will be an error in a future version of `fitsio`!\" % keys,\n DeprecationWarning, stacklevel=2)\n\n kwargs = {\n 'lower': lower,\n 'upper': upper,\n 'vstorage': vstorage,\n 'case_sensitive': case_sensitive,\n 'verbose': verbose,\n 'trim_strings': trim_strings\n }\n\n read_kwargs = {}\n if columns is not None:\n read_kwargs['columns'] = columns\n if rows is not None:\n read_kwargs['rows'] = rows\n\n with FITS(filename, **kwargs) as fits:\n\n if ext is None:\n for i in xrange(len(fits)):\n if fits[i].has_data():\n ext = i\n break\n if ext is None:\n raise IOError(\"No extensions have data\")\n\n item = _make_item(ext, extver=extver)\n\n data = fits[item].read(**read_kwargs)\n if header:\n h = fits[item].read_header()\n return data, h\n else:\n return data","def openFile(dir):\n # If path is a directory\n if os.path.isdir(dir):\n # Check file sizes from first file\n Nt = len(glob.glob(dir + \"/1_*.txt\")) # Nt\n tmp = np.loadtxt(dir + \"/1_0.txt\") \n Ny, Nx = tmp.shape\n # Output array\n V = np.zeros((Nt, 2, Ny, Nx))\n for n in range(Nt):\n V1 = np.loadtxt(\"{0}/1_{1}.txt\".format(dir, n))\n V2 = np.loadtxt(\"{0}/2_{1}.txt\".format(dir, n))\n V[n] = V1, V2\n return V\n # If path is a file\n elif os.path.isfile(dir):\n if '.npy' in dir: # Numpy data file\n return np.load(dir)\n elif '.txt' in dir: # Plain text data file\n return np.loadtxt(dir)\n else:\n raise Exception(\"File extension not supported.\")\n else:\n raise Exception(\"Path is not supported.\")","def _openFlt(self, fname):\n image = np.loadtxt(fname)\n\n if(image !=None):\n M,N=(int(image[0]), int(image[1]))\n image = image[2:image.shape[0]]\n image = image.reshape((M,N))\n else:\n raise IOError, \"Image file can not be opened\"\n\n return image","def read_image(fname, roi=None, dset_name='default', parallelism=1):\n\n from functools import partial\n from numpy import array, ndarray\n from multiprocessing import Pool, cpu_count\n\n if isinstance(fname, str):\n fmt = fname.split('.')[-1]\n \n if fmt == '.h5' or fmt == '.hdf5':\n reader = partial(readers[fmt], roi=roi, dset_name=dset_name)\n else:\n reader = partial(readers[fmt], roi=roi)\n \n result = reader(fname)\n\n elif isinstance(fname, (tuple, list, ndarray)):\n fmt = fname[0].split('.')[-1]\n if fmt == '.h5' or fmt == '.hdf5':\n reader = partial(readers[fmt], roi=roi, dset_name=dset_name)\n else:\n reader = partial(readers[fmt], roi=roi)\n\n if parallelism == 1:\n result = array([reader(f) for f in fname])\n\n else:\n if parallelism == -1:\n num_cores = cpu_count()\n else:\n num_cores = min(parallelism, cpu_count())\n\n with Pool(num_cores) as pool:\n result = array(pool.map(reader, fname))\n else:\n raise TypeError(\n \"First argument must be string for a one file or (tuple, list, ndarray) for many files\"\n )\n\n return result","def _load(self, pkgpart, part_dict):\n # call parent to do generic aspects of load\n super(Image, self)._load(pkgpart, part_dict)\n # set file extension\n self.__ext = posixpath.splitext(pkgpart.partname)[1]\n # return self-reference to allow generative calling\n return self","def loadFile(filterExt):\n basicFilter = \"*.\" + filterExt\n filePath = fileDialog2(fileFilter=basicFilter, dialogStyle=2, fm=1)\n if(filePath != None):\n #openfile = open('/Users/camtton/Desktop/drawing.svg', 'r')\n tokens = getSVGpath(filePath[0])\n return tokens\n else:\n print 'Please select a %s file'%(filterExt)","def __init__(self, filepath: str):\n self.filetype: str = filepath[len(filepath) - 3:].upper()\n self.tags = None\n self.locations: [Location] = None\n self.intermediaryImage = None\n self.outlined = None\n if self.filetype == 'TIF':\n print('found tif')\n with TiffFile(filepath) as tif:\n # fileInfo(tif)\n self.tags = metadataGeoTags(tif)\n self.image = tif.asarray()\n elif self.filetype == 'PNG' or self.filetype == 'JPG':\n print('found png')\n self.image = cv2.imread(filepath, cv2.IMREAD_UNCHANGED)\n else:\n print('invalid file type:', self.filetype)","def get_infile(filename):\r\n if filename.endswith(\".gz\"):\r\n fin = GzipFile(filename, \"rb\")\r\n else:\r\n fin = open(filename, \"U\")\r\n return fin","def get_infile(filename):\r\n if filename.endswith(\".gz\"):\r\n fin = GzipFile(filename, \"rb\")\r\n else:\r\n fin = open(filename, \"U\")\r\n return fin","def img_read(name):\n\n img = cv2.imread(name)\n\n return img","def get_split(split_name, dataset_dir, file_pattern=None, reader=None):\n if split_name not in SPLITS_TO_SIZES:\n raise ValueError('split name %s was not recognized.' % split_name)\n\n if not file_pattern:\n file_pattern = _FILE_PATTERN\n file_pattern = os.path.join(dataset_dir, file_pattern % split_name)\n\n # Allowing None in the signature so that dataset_factory can use the default.\n if not reader:\n reader = tf.TFRecordReader\n\n keys_to_features = {\n 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''),\n 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpg'),\n 'image/class/label': tf.FixedLenFeature(\n [], tf.int64, default_value=tf.zeros([], dtype=tf.int64)),\n 'image/height': tf.FixedLenFeature(\n [], tf.int64, default_value=tf.zeros([], dtype=tf.int64)),\n 'image/width':tf.FixedLenFeature(\n [], tf.int64, default_value=tf.zeros([], dtype=tf.int64)), \n }\n\n items_to_handlers = {\n 'image': slim.tfexample_decoder.Image(),\n 'label': slim.tfexample_decoder.Tensor('image/class/label'),\n 'height': slim.tfexample_decoder.Tensor('image/height'),\n 'width': slim.tfexample_decoder.Tensor('image/width'),\n \n }\n\n decoder = slim.tfexample_decoder.TFExampleDecoder(\n keys_to_features, items_to_handlers)\n\n labels_to_names = None\n if dataset_utils.has_labels(dataset_dir):\n labels_to_names = dataset_utils.read_label_file(dataset_dir)\n\n return slim.dataset.Dataset(\n data_sources=file_pattern,\n reader=reader,\n decoder=decoder,\n num_samples=SPLITS_TO_SIZES[split_name],\n num_classes=2,\n items_to_descriptions=_ITEMS_TO_DESCRIPTIONS,\n labels_to_names=labels_to_names)","def load_file(path='vgg19.mat'):\n\t\tfile=loadmat(path)\n\t\tfile=file['layers']\n\t\tprint(\"Success load_file\")\n\t\treturn file","def _load(f, as_gray=False):\n # importing io is quite slow since it scans all the backends\n # we lazy import it here\n from skimage.io import imread\n return imread(os.path.join(data_dir, f), plugin='pil', as_gray=as_gray)","def im_open(path):\n\n try:\n assert os.path.isdir(path)\n #get file list in directory - glob includes full path\n files = sorted(glob.glob('{}{}*'.format(path,os.sep)), key=sort_key) \n #load the collection\n raw_stack = io.imread_collection(files)\n #turn the collection into a np array and remove extraneous OCT portion from 1025:1083 on x axis. (z,y,x)\n #if .bmp files are open (from pv-oct), the slicing will not affect them, the x-axis is only 540 pixels.\n stack = io.collection.concatenate_images(raw_stack)[:,:,0:1024]\n \n return stack\n\n except AssertionError:\n sys.exit(\"A non-directory object was given to the __open__ function\")","def get_file_type(file_path):\n ext = pathlib.Path(file_path).suffix\n return \"video\" if ext == \".avi\" else \"image\"","def loadFromFile(cls , filename):\n if FortIO.isFortranFile( filename ):\n return EclGrid( filename )\n else:\n return EclGrid.loadFromGrdecl( filename )","def render_vtk(file_name):\n import vtk\n\n # Read the source file.\n reader = vtk.vtkUnstructuredGridReader()\n reader.SetFileName(file_name)\n reader.Update() # Needed because of GetScalarRange\n output = reader.GetOutput()\n scalar_range = output.GetScalarRange()\n\n # Create the mapper that corresponds the objects of the vtk.vtk file\n # into graphics elements\n mapper = vtk.vtkDataSetMapper()\n mapper.SetInputData(output)\n mapper.SetScalarRange(scalar_range)\n\n # Create the Actor\n actor = vtk.vtkActor()\n actor.SetMapper(mapper)\n\n # Create the Renderer\n renderer = vtk.vtkRenderer()\n renderer.AddActor(actor)\n renderer.SetBackground(1, 1, 1) # Set background to white\n\n # Create the RendererWindow\n renderer_window = vtk.vtkRenderWindow()\n renderer_window.AddRenderer(renderer)\n\n # Create the RendererWindowInteractor and display the vtk_file\n interactor = vtk.vtkRenderWindowInteractor()\n interactor.SetRenderWindow(renderer_window)\n interactor.Initialize()\n interactor.Start()","def dispatch_loader(fname, direc, sep=\"\\t\"):\n ext = fname.split(\".\")[-1]\n # print('Loading from: {}/{}'.format(direc, fname))\n if ext in (\"tsv\" or \"txt\"):\n return load_df_from_txt(fname, direc, sep)\n elif ext == \"pkl\":\n return load_df_from_pkl(fname, direc)\n else:\n raise IOError(\"Unexpected file extension {}.\".format(ext))","def __init__(self, fits_file, ext=0):","def read(dataset = \"training\", path = \".\"):\n\n if dataset is \"training\":\n fname_img = os.path.join(path, 'train-images-idx3-ubyte')\n fname_lbl = os.path.join(path, 'train-labels-idx1-ubyte')\n elif dataset is \"testing\":\n fname_img = os.path.join(path, 't10k-images-idx3-ubyte')\n fname_lbl = os.path.join(path, 't10k-labels-idx1-ubyte')\n else:\n raise ValueError, \"dataset must be 'testing' or 'training'\"\n\n # Load everything in some numpy arrays\n with open(fname_lbl, 'rb') as flbl:\n magic, num = struct.unpack(\">II\", flbl.read(8))\n lbl = np.fromfile(flbl, dtype=np.int8)\n\n with open(fname_img, 'rb') as fimg:\n magic, num, rows, cols = struct.unpack(\">IIII\", fimg.read(16))\n img = np.fromfile(fimg, dtype=np.uint8).reshape(len(lbl), rows, cols)\n\n get_img = lambda idx: (lbl[idx], img[idx])\n\n # Create an iterator which returns each image in turn\n for i in xrange(len(lbl)):\n yield get_img(i)","def imread(filename, *args, **kwargs):\r\n try:\r\n netpbm = NetpbmFile(filename)\r\n image = netpbm.asarray()\r\n finally:\r\n netpbm.close()\r\n return image","def image_loader(fileobj):\n if isinstance(fileobj, six.string_types):\n return cv2.imread(fileobj, cv2.IMREAD_COLOR)[..., ::-1] #bgr->rgb\n elif isinstance(fileobj, bytes):\n byte_arr = bytearray(fileobj)\n else:\n byte_arr = bytearray(fileobj.read())\n \n return cv2.imdecode(np.asarray(byte_arr, dtype=np.uint8), cv2.IMREAD_COLOR)[..., ::-1] #bgr->rgb","def loader(path):\n img = np.load(path)\n img = img[1:4]\n if np.random.choice((True, False)):\n img = img[:, :, ::-1]\n img = np.array(img)\n if np.random.choice((True, False)):\n img = img[:, ::-1, :]\n img = np.array(img)\n\n img = img.transpose((1, 2, 0)) # pytorch is going to rotate it back\n return img","def read_image(self, item):\n assert item['image_dtype'] == 'uint16'\n\n filename = os.path.join(self.home(item['basename']))\n s = open(filename, 'rb').read()\n assert hashlib.md5(s).hexdigest() == item['md5']\n img = np.fromstring(s, dtype=item['image_dtype']).byteswap()\n img = img.reshape(item['image_shape'])\n return img","def read_file(path: str, flag: bool, size=224):\n img_path = sorted(os.listdir(path))\n img_num = len(img_path)\n img_data = np.zeros((img_num, 224, 224, 3), dtype=np.uint8)\n img_label = np.zeros(img_num, dtype=np.uint8)\n for lps, no in enumerate(img_path):\n img = cv2.imread(os.path.join(path, no))\n img_data[lps, :, :] = cv2.resize(img, (224, 224))\n if flag:\n img_label[lps] = int(no.split(\"_\")[0])\n if flag:\n return img_data, img_label\n else:\n return img_data","def __getitem__(self, idx):\n im = Image.open(self.data_path + self.sample_df.loc[idx,'filename'])\n # load label\n label = torch.tensor(self.sample_df.loc[idx,'abnormal_XR'])\n # load mask\n if self.load_mask:\n mask = Image.open(self.data_path + self.sample_df.loc[idx,'mask_filename'])\n else:\n mask = None\n\n # load semi-label\n if self.load_semilabels:\n semi_label = torch.tensor(self.sample_df.loc[idx, 'semi_label'])\n else:\n semi_label = None\n\n im, mask = self.transform(im, mask)\n\n return im, label, mask, semi_label, torch.tensor(idx)","def load_metaimage(path, voxel=True):\n\n meta = SimpleITK.ReadImage(path)\n\n if voxel:\n voxel_data = SimpleITK.GetArrayFromImage(meta)\n meta = [voxel_data, meta]\n\n return meta","def tiffread(f):\n if type(f) is str:\n # single image\n im = tf.imread(f)\n return im\n\n elif type(f) is list and len(f) == 3:\n # return rgb stack\n f.sort(reverse=True) # so r, g, b\n ims = [tf.imread(x) for x in f]\n return np.dstack(ims)\n else:\n raise ValueError(\"f must be a string or list of 3 strings\")","def read(path: Union[Path, str]) -> np.ndarray:\n return _reader.imread(str(path))","def read(fname, fmt=None):\n if not fmt:\n fmt = fname.split(\".\")[-1]\n\n if fmt in ['yml', 'yaml']:\n return _storage_read(fname, yaml.safe_load)\n elif fmt == \"json\":\n return _storage_read(fname, json.load)\n elif fmt == \"pickle\":\n return _storage_read(fname, pickle.load, 'rb')\n else:\n raise Exception()","def __getitem__(self, idx):\n\n image = Image.open(self.filenames[idx])\n image = self.transform(image)\n\n return image, self.labels[idx]","def _get_img_tensor(self, fname, internal_transform):\n transforms = list(self.base_transforms)\n if internal_transform:\n transforms.insert(1, internal_transform)\n\n return T.Compose(transforms)(Image.open(self.imgs_root / fname))"],"string":"[\n \"def getReadersFromFilenames(self):\\n\\t\\tfor i in self.readers:\\n\\t\\t\\tdel i\\n\\t\\tself.readers = []\\n\\n\\t\\tif not self.filenames:\\n\\t\\t\\traise Logging.GUIError(\\\"No files could be found\\\", \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\\"For some reason, no files were listed to be imported.\\\")\\t\\t \\n\\t\\t\\t\\t\\t\\n\\t\\tfiles = self.filenames\\n\\t\\tprint \\\"Determining readers from \\\", self.filenames\\n\\n\\t\\tisRGB = 1\\n\\t\\tself.ext = files[0].split(\\\".\\\")[-1].lower()\\n\\t\\tdim = self.dimMapping[self.ext]\\n\\t\\t# Initially flip the image if it's tiff, png or jpg.\\n\\t\\t# In setVerticalFlip we negate the setting to have it set correctly.\\n\\t\\tif self.ext.lower() in [\\\"png\\\", \\\"jpg\\\", \\\"jpeg\\\"]:\\n\\t\\t\\tself.flipVertically = True\\n\\t\\tif self.ext in [\\\"tif\\\", \\\"tiff\\\"]:\\n\\t\\t\\treader = vtkbxd.vtkExtTIFFReader()\\n\\t\\t\\treader.SetFileName(files[0])\\n\\t\\t\\treader.UpdateInformation()\\n\\t\\t\\tif reader.GetNumberOfScalarComponents() >= 3:\\n\\t\\t\\t\\tprint \\\"MODE IS RGB, IS AN RGB IMAGE\\\"\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprint \\\"MODE ISN'T RGB, THEREFORE NOT RGB\\\"\\n\\t\\t\\t\\tisRGB = 0\\n\\t\\t\\trdr = self.getReaderByExtension(self.ext, isRGB)\\n\\t\\t\\trdr.SetFileName(files[0])\\n\\t\\t\\tif rdr.GetNumberOfSubFiles() > 1:\\n\\t\\t\\t\\tdim = 3\\n\\t\\t\\t\\t\\n\\t\\tself.isRGB = isRGB\\n\\t\\tself.is3D = (dim == 3)\\n\\t\\t\\n\\t\\tdirName = os.path.dirname(files[0])\\n\\t\\tprint \\\"THERE ARE\\\", self.slicesPerTimepoint, \\\"SLICES PER TIMEPOINT\\\"\\n\\t\\tself.ext = files[0].split(\\\".\\\")[-1].lower()\\n\\t\\t\\n\\t\\tif dim == 3:\\n\\t\\t\\ttotalFiles = len(files)\\n\\t\\t\\tfor i, file in enumerate(files):\\n\\t\\t\\t\\trdr = self.getReaderByExtension(self.ext, isRGB)\\n\\t\\t\\t\\trdr.SetFileName(file)\\n\\t\\t\\t\\tself.readers.append(rdr)\\n\\t\\t\\treturn\\n\\t\\t\\t\\n\\t\\ttotalFiles = len(files) / self.slicesPerTimepoint\\n\\n\\t\\timgAmnt = len(files)\\n\\t\\tif totalFiles == 1:\\n\\t\\t\\trdr = self.getReaderByExtension(self.ext, isRGB)\\n\\t\\t\\tarr = vtk.vtkStringArray()\\n\\t\\t\\tfor fileName in files:\\n\\t\\t\\t\\tarr.InsertNextValue(os.path.join(dirName, fileName))\\n\\t\\t\\trdr.SetFileNames(arr)\\n\\t\\t\\tself.readers.append(rdr)\\n\\t\\t\\treturn\\n\\t\\t\\t\\n\\t\\tif imgAmnt > 1:\\n\\t\\t\\t# If the pattern doesn't have %, then we just use\\n\\t\\t\\t# the given filenames and allocate them to timepoints\\n\\t\\t\\t# using slicesPerTimepoint slices per timepoint\\n\\t\\t\\tntps = len(files) / self.slicesPerTimepoint\\n\\t\\t\\tfilelst = files[:]\\n\\t\\t\\t# dirn #TODO: what was this?\\n\\t\\t\\tfor tp in range(0, ntps):\\n\\t\\t\\t\\trdr = self.getReaderByExtension(self.ext, isRGB)\\n\\t\\t\\t\\tarr = vtk.vtkStringArray()\\n\\t\\t\\t\\tfor i in range(0, self.slicesPerTimepoint):\\n\\t\\t\\t\\t\\tarr.InsertNextValue(filelst[0])\\n\\t\\t\\t\\t\\tfilelst = filelst[1:]\\n\\t\\t\\t\\trdr.SetFileNames(arr)\\n\\t\\t\\t\\trdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0, self.slicesPerTimepoint - 1)\\n\\t\\t\\t\\trdr.SetDataSpacing(self.spacing)\\n\\t\\t\\t\\trdr.SetDataOrigin(0, 0, 0)\\n\\t\\t\\t\\tself.readers.append(rdr)\\n\\t\\t\\treturn\\n\\t\\t\\n\\t\\telif imgAmnt == 1:\\n\\t\\t\\t# If only one file\\n\\t\\t\\trdr = self.getReaderByExtension(self.ext, isRGB)\\n\\t\\t\\trdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0, self.slicesPerTimepoint - 1)\\n\\t\\t\\trdr.SetDataSpacing(self.spacing)\\n\\t\\t\\trdr.SetDataOrigin(0, 0, 0)\\n\\t\\t\\trdr.SetFileName(files[0])\\n\\n\\t\\t\\tLogging.info(\\\"Reader = \\\", rdr, kw = \\\"io\\\")\\n\\t\\t\\tself.readers.append(rdr)\",\n \"def _get_reader(self, filepath: str):\\n file_extension = os.path.splitext(filepath)[-1]\\n\\n self._validate_file(filepath)\\n\\n if file_extension == \\\".ipynb\\\":\\n return NotebookReader(filepath)\\n elif file_extension in [\\\".py\\\", \\\".r\\\"]:\\n return FileReader(filepath)\\n else:\\n raise ValueError(f\\\"File type {file_extension} is not supported.\\\")\",\n \"def imread_wrapper(file):\\n p = Path(file)\\n if len(p.suffixes) == 2:\\n series = int(Path(p.stem).stem)\\n else:\\n series = int(p.stem)\\n return imread(file, series=series)\",\n \"def _get_reader_class(basename: str) -> Type[BaseEEGReader]:\\n if basename.endswith(\\\".h5\\\"):\\n return RamulatorHDF5Reader\\n elif basename.endswith((\\\".bdf\\\", \\\".mff\\\", \\\".raw\\\")):\\n return ScalpEEGReader\\n elif basename.endswith(\\\".npy\\\"):\\n return NumpyEEGReader\\n else:\\n return SplitEEGReader\",\n \"def imread(filename):\\n filename = process(filename)\\n ext = os.path.splitext(filename)[1]\\n if ext.lower() == '.pfm':\\n return load_pfm(filename)\\n elif ext.lower() == '.dng':\\n return load_dng(filename)\\n else:\\n loaded = cv2.imread(filename, flags=cv2.IMREAD_ANYDEPTH + cv2.IMREAD_COLOR)\\n if loaded is None:\\n raise IOError('Could not read {0}'.format(filename))\\n else:\\n return loaded\",\n \"def ReadVTK(self, filename, element_type=None):\\n\\n try:\\n import vtkInterface as vtki\\n except IOError:\\n raise IOError(\\\"vtkInterface is not installed. Please install it first using 'pip install vtkInterface'\\\")\\n\\n self.__reset__()\\n\\n vmesh = vtki.UnstructuredGrid(filename)\\n flat_elements = np.copy(np.delete(vmesh.cells, vmesh.offset))\\n\\n if not np.all(vmesh.celltypes == vmesh.celltypes[0]):\\n raise IOError(\\\"Cannot read VTK files with hybrid elements\\\")\\n\\n cellflag = vmesh.celltypes[0]\\n\\n if cellflag == 5:\\n self.element_type = \\\"tri\\\"\\n divider = 3\\n elif cellflag == 9:\\n self.element_type = \\\"quad\\\"\\n divider = 4\\n elif cellflag == 10:\\n self.element_type = \\\"tet\\\"\\n divider = 4\\n elif cellflag == 12:\\n self.element_type = \\\"hex\\\"\\n divider = 8\\n elif cellflag == 3:\\n self.element_type = \\\"line\\\"\\n divider = 2\\n else:\\n raise IOError(\\\"VTK element type not understood\\\")\\n\\n if element_type is not None:\\n if self.element_type != element_type:\\n raise ValueError(\\\"VTK file does not contain {} elements\\\".format(element_type))\\n\\n\\n self.elements = np.ascontiguousarray(flat_elements.reshape(int(flat_elements.shape[0]/divider),divider), dtype=np.uint64)\\n self.points = np.ascontiguousarray(vmesh.points, dtype=np.float64)\\n self.nelem = self.elements.shape[0]\\n self.nnode = self.points.shape[0]\\n\\n if self.points.shape[1] == 3:\\n if np.allclose(self.points[:,2],0.):\\n self.points = np.ascontiguousarray(self.points[:,:2])\\n\\n if self.element_type == \\\"tri\\\" or self.element_type == \\\"quad\\\":\\n self.GetEdges()\\n self.GetBoundaryEdges()\\n elif self.element_type == \\\"tet\\\" or self.element_type == \\\"hex\\\":\\n self.GetFaces()\\n self.GetBoundaryFaces()\\n self.GetBoundaryEdges()\\n\\n return\",\n \"def read_image(path, file_format='nii.gz'):\\n path = path + '.' + file_format\\n if file_format == 'npy':\\n image = np.load(path)\\n elif file_format == 'npz':\\n image = np.load(path)['arr_0']\\n elif file_format in ('png', 'jpg'):\\n image = np.array(imageio.imread(path))\\n elif file_format == 'dcm':\\n image = np.array(imageio.volread(path, 'DICOM'))\\n elif file_format in ('nii', 'nii.gz'):\\n image = nib.load(path).get_data()\\n else:\\n raise ValueError('invalid --input_type : {}'.format(file_format))\\n\\n return image\",\n \"def get_type(ext):\\n if ext.lower() in Asset.SUPPORTED_IMAGE_EXT['in']:\\n return 'image'\\n return 'file'\",\n \"def load_image(fname):\\n return load_tiff(fname)\",\n \"def reader(self, idx):\\n # Get the path of input image and groundtruth mask.\\n input_path, gtmask_path = self.imgs[idx]\\n input_img, gt_img = self.loader(input_path, gtmask_path)\\n return input_img, gt_img\",\n \"def readImage(self, path, tt=1):\\n return cv2.imread( path, tt)\",\n \"def read_image(self, filePath):\\n if filePath.endswith(\\\".dcm\\\"):\\n image = sitk.ReadImage(filePath)\\n image = sitk.GetArrayFromImage(image).astype(\\\"int16\\\")\\n image = np.expand_dims(image[0,:,:], -1)\\n elif filePath.endswith(\\\".png\\\"):\\n image = cv2.imread(filePath)\\n image = np.array(image, dtype = \\\"int16\\\")\\n elif filePath.endswith(\\\".mha\\\"):\\n image = sitk.ReadImage(filePath)\\n image = sitk.GetArrayFromImage(image).astype(\\\"int16\\\")\\n image = np.transpose(image,(1,2,0))\\n return image\",\n \"def __getitem__(self, idx):\\n image = Image.open(self.filenames[idx]) # PIL image\\n image = self.transform(image)\\n return image\",\n \"def vtk_xml_reader(self):\\n reader = vtk.vtkXMLStructuredGridReader()\\n reader.SetFileName(self.file)\\n reader.Update()\\n assert isinstance(reader, vtk.vtkObject)\\n return reader\",\n \"def load(self, file, lazy=True):\\n # individual files for each slice\\n # we got one file, nice!\\n \\n if not lazy:\\n\\n if file in self.imagedict.keys():\\n return self.imagedict[file]\\n else:\\n self.imagedict[file] = self.load(file, True)\\n self.imagedict[file] *= 1\\n return self.imagedict[file]\\n \\n else:\\n \\n ending = splitext(file)[-1].lower()\\n if ending in ['.nii', '.hdr', '.nii.gz', '.gz']:\\n if self.correct_orientation:\\n vol = ni.open_image(file, verbose=False)\\n self.affine = vol.get_aligned_transformation(\\\"RAS\\\")\\n data = vol.aligned_volume\\n else:\\n f = nib.load(file)\\n self.affine = f.affine\\n self.pixdim = np.asarray(f.header['pixdim'][1:])\\n data = f.get_data()\\n return data\\n # elif ending in ['.nrrd', '.nhdr']:\\n # if self.correct_orientation:\\n # vol = nr.open_image(file, verbose=False)\\n # self.affine = vol.get_aligned_transformation(\\\"RAS\\\")\\n # f = vol.aligned_volume\\n # else:\\n # try:\\n # f, h = nrrd.read(file)\\n # except:\\n # print('could not read file {}'.format(file))\\n # logging.getLogger('data').error('could not read file {}'.format(file))\\n # raise Exception('could not read file {}'.format(file))\\n # self.affine = np.eye(4)\\n # return f\\n # elif ending in ['.dcm']:\\n # f = pydicom.dcmread(file).pixel_array\\n # return f\\n # elif ending in ['.mha', '.mhd']:\\n # f = skio.imread(file, plugin='simpleitk')\\n # self.affine = np.eye(4)\\n # return f\\n elif ending in ['.png', '.pgm', '.pnm']:\\n data = imread(file)\\n if len(data.shape) > 2:\\n return np.transpose(data, [2, 0, 1])\\n else:\\n return data\\n return imread(file)\\n else:\\n raise Exception('{} not known'.format(ending))\",\n \"def read(infile):\\n _, ext = os.path.splitext(infile)\\n ext = ext.strip('.')\\n return read_funcs[ext](infile)\",\n \"def imread(fname):\\r\\n return skimage.io.imread(fname)\",\n \"def _get_file_object(infilename):\\n\\n _, extension = os.path.splitext(infilename)\\n if extension.lower() == '.spe':\\n return parsers.SpeFile(infilename)\\n elif extension.lower() == '.spc':\\n return parsers.SpcFile(infilename)\\n elif extension.lower() == '.cnf':\\n return parsers.CnfFile(infilename)\\n else:\\n raise NotImplementedError(\\n 'File type {} can not be read'.format(extension))\",\n \"def viewFileByExt(filename):\\n filename_ext = file_func.getFilenameExt(filename)\\n if filename_ext:\\n filename_ext = filename_ext.lower()\\n if filename_ext in PDF_FILENAME_EXT:\\n from . import pdf_func\\n return pdf_func.viewPDF(pdf_filename=filename)\\n\\n elif filename_ext in IMG_FILENAME_EXT:\\n from . import img_func\\n return img_func.viewImage(img_filename=filename)\\n\\n elif filename_ext in OFFICE_FILENAME_EXT:\\n from . import office_func\\n return office_func.openInLibreOffice(filename)\\n else:\\n log_func.warning(u'Not supported view file type <%s>' % filename_ext)\\n else:\\n log_func.warning(u'Not defined ext of filename <%s>' % filename)\\n return False\",\n \"def iread(filename, *args, verbose=True, **kwargs):\\n\\n # determine if file is valid:\\n # assert isinstance(filename, str), 'filename must be a string'\\n\\n\\n # TODO read options for image\\n # opt = {\\n # 'uint8': False,\\n # 'single': False,\\n # 'double': False,\\n # 'grey': False,\\n # 'grey_709': False,\\n # 'gamma': 'sRGB',\\n # 'reduce': 1.0,\\n # 'roi': None\\n # }\\n\\n if isinstance(filename, str) and (filename.startswith(\\\"http://\\\") or filename.startswith(\\\"https://\\\")):\\n # reading from a URL\\n\\n resp = urllib.request.urlopen(filename)\\n array = np.asarray(bytearray(resp.read()), dtype=\\\"uint8\\\")\\n image = cv.imdecode(array, -1)\\n print(image.shape)\\n return (image, filename)\\n\\n elif isinstance(filename, (str, Path)):\\n # reading from a file\\n\\n path = Path(filename).expanduser()\\n\\n if any([c in \\\"?*\\\" for c in str(path)]):\\n # contains wildcard characters, glob it\\n # recurse and return a list\\n # https://stackoverflow.com/questions/51108256/how-to-take-a-pathname-string-with-wildcards-and-resolve-the-glob-with-pathlib\\n \\n parts = path.parts[1:] if path.is_absolute() else path.parts\\n p = Path(path.root).glob(str(Path(\\\"\\\").joinpath(*parts)))\\n pathlist = list(p)\\n\\n if len(pathlist) == 0 and not path.is_absolute():\\n # look in the toolbox image folder\\n path = Path(__file__).parent / \\\"images\\\" / path\\n parts = path.parts[1:] if path.is_absolute() else path.parts\\n p = Path(path.root).glob(str(Path(\\\"\\\").joinpath(*parts)))\\n pathlist = list(p)\\n \\n if len(pathlist) == 0:\\n raise ValueError(\\\"can't expand wildcard\\\")\\n\\n imlist = []\\n pathlist.sort()\\n for p in pathlist:\\n imlist.append(iread(p, **kwargs))\\n return imlist\\n\\n else:\\n # read single file\\n\\n if not path.exists():\\n if path.is_absolute():\\n raise ValueError(f\\\"file {filename} does not exist\\\")\\n # file doesn't exist\\n # see if it matches the supplied images\\n path = Path(__file__).parent / \\\"images\\\" / path\\n\\n if not path.exists():\\n raise ValueError(f\\\"file {filename} does not exist, and not found in supplied images\\\")\\n\\n # read the image\\n # TODO not sure the following will work on Windows\\n im = cv.imread(path.as_posix(), **kwargs) # default read-in as BGR\\n\\n if im is None:\\n # TODO check ValueError\\n raise ValueError(f\\\"Could not read {filename}\\\")\\n\\n return (im, str(path))\\n\\n elif islistof(filename, (str, Path)):\\n # list of filenames or URLs\\n # assume none of these are wildcards, TODO should check\\n out = []\\n for file in filename:\\n out.append(iread(file, *args))\\n return out\\n else:\\n raise ValueError(filename, 'invalid filename')\",\n \"def img_in(filename):\\n temp_img = Image.open(filename)\\n img = np.array(temp_img)\\n name = filename.split('.')[-2]\\n return name, img\",\n \"def _read_file(self):\\n extension = self.path.split('.')[-1]\\n if extension!='avi':\\n raise Exception(\\\"Invalid Format\\\")\\n\\n return cv2.VideoCapture(self.path)\",\n \"def MFileReader(fvcom, *args, **kwargs):\\n\\n if isinstance(fvcom, str):\\n FVCOM = FileReader(fvcom, *args, **kwargs)\\n else:\\n for file in fvcom:\\n if file == fvcom[0]:\\n FVCOM = FileReader(file, *args, **kwargs)\\n else:\\n FVCOM += FileReader(file, *args, **kwargs)\\n\\n return FVCOM\",\n \"def read_image_file(file_name):\\n return torch.from_numpy(np.asarray(Image.open(file_name).convert('L')))\",\n \"def load(cls,filename,format=None,**kwargs):\\n\\n\\t\\tif format is None:\\n\\t\\t\\t\\n\\t\\t\\textension = filename.split(\\\".\\\")[-1]\\n\\t\\t\\tif extension in [\\\"fit\\\",\\\"fits\\\"]:\\n\\t\\t\\t\\tformat=\\\"fits\\\"\\n\\t\\t\\telif extension in [\\\"npy\\\",\\\"npz\\\"]:\\n\\t\\t\\t\\tformat=\\\"npz\\\"\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise IOError(\\\"File format not recognized from extension '{0}', please specify it manually\\\".format(extension))\\n\\n\\t\\tif format==\\\"fits\\\":\\n\\t\\t\\treturn loadFITS(cls,filename)\\n\\t\\telif format==\\\"npz\\\":\\n\\t\\t\\treturn loadNPZ(cls,filename)\\n\\t\\telse:\\n\\t\\t\\tangle,data = format(filename,**kwargs)\\n\\t\\t\\treturn cls(data,angle)\",\n \"def get_input(self, idx):\\r\\n img_filename = self.root / \\\"images\\\" / self._image_array[idx]\\r\\n x = Image.open(img_filename)\\r\\n return x\",\n \"def inferReader(filePath):\\n for reg, reader in six.iteritems(REGEXES):\\n match = re.match(reg, filePath)\\n if match and match.group() == filePath:\\n debug('Inferred reader for {}: {}'\\n .format(filePath, reader.__name__))\\n return reader\\n raise SerpentToolsException(\\n 'Failed to infer filetype and thus accurate reader from'\\n 'file path {}'.format(filePath)\\n )\",\n \"def open_image(self, filename):\\n return np.array(self.ds['test'].load_image(filename))\",\n \"def reader(name, version=None, mimetype=None):\\n\\treturn _data_processor('read', name, version, mimetype)\",\n \"def _read_ext(cls, hdulist, extname, **kwargs):\\n try:\\n if cls == Table:\\n # use Table.read method to ensure extra header keywords are loaded\\n # as metadata\\n obj = Table.read(hdulist, hdu=extname)\\n obj = Table(obj, **kwargs)\\n else:\\n obj = cls(hdulist[extname].data, **kwargs)\\n except Exception as e:\\n raise IOError('%s: Impossible to open extension %s as a %s\\\\n%s' % (\\n os.path.basename(hdulist.filename()), extname, cls.__name__, e))\\n return obj\",\n \"def loadVtk(self, fname):\\n\\n reader = vtk.vtkUnstructuredGridReader()\\n reader.SetFileName(filename)\\n reader.Update()\\n self._vtk = reader.GetOutput()\",\n \"def openFile(path_name):\\n if os.path.isdir(path_name):\\n reader = sitk.ImageSeriesReader()\\n dicom_names = reader.GetGDCMSeriesFileNames(path_name)\\n reader.SetFileNames(dicom_names)\\n image_object = reader.Execute()\\n \\n elif os.path.isfile(path_name):\\n image_object = sitk.ReadImage(path_name)\\n\\n else:\\n print(\\\"Path name wrong.\\\")\\n return None\\n\\n return image_object\",\n \"def image(fname):\\n return cv2.imread(fname)\",\n \"def imagefile(self):\\n if self.__filetype==\\\"flatWarp\\\" :\\n ext = \\\".fw\\\"\\n elif self.__filetype==\\\"camWarp\\\" :\\n ext = \\\".camWarp\\\"\\n elif self.__filetype==\\\"raw\\\" :\\n ext = \\\".Data.dat\\\"\\n else :\\n raise ValueError(f\\\"requested file type {self.__filetype} not recognized\\\")\\n\\n return self.__imagefolder/self.file.replace(\\\".im3\\\", ext)\",\n \"def get_reader(fn):\\n if is_bed(fn):\\n return BedReader(fn)\\n elif is_vcf(fn):\\n return VcfReader(fn)\\n else:\\n raise ValueError(\\\"Could not get reader for %s\\\" % fn)\",\n \"def load_file(self):\\n extensions = DataReader().get_supported_extensions_as_string()\\n file_name, _ = QFileDialog.getOpenFileName(self, \\\"Open data set\\\", \\\"\\\",\\n \\\"Images (\\\" + extensions + \\\")\\\")\\n if not file_name:\\n return\\n\\n self.render_widget.load_file(file_name)\\n self.switch_to_simple()\",\n \"def get_split(split_name, dataset_dir, file_pattern=None, reader=None):\\n if split_name not in SPLITS_TO_SIZES:\\n raise ValueError('split name %s was not recognized.' % split_name)\\n \\n if not file_pattern:\\n file_pattern = FILE_PATTERN\\n file_pattern = os.path.join(dataset_dir, file_pattern % split_name)\\n \\n # Allowing None in the signature so that dataset_factory can use the default.\\n if reader is None:\\n reader = tf.TFRecordReader\\n# #文件名格式\\n# if file_pattern is None:\\n# file_pattern = _get_output_filename('tfrecords','voc_2007_train')#need fix your filename\\n# print(file_pattern)\\n \\n # 适配器1：将example反序列化成存储之前的格式。由tf完成\\n keys_to_features = {\\n 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''),\\n 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpg'),\\n 'image/height': tf.FixedLenFeature([1], tf.int64),\\n 'image/width': tf.FixedLenFeature([1], tf.int64),\\n 'image/channels': tf.FixedLenFeature([1], tf.int64),\\n 'image/shape': tf.FixedLenFeature([3], tf.int64),\\n 'image/object/bbox/xmin': tf.VarLenFeature(dtype=tf.float32),\\n 'image/object/bbox/ymin': tf.VarLenFeature(dtype=tf.float32),\\n 'image/object/bbox/xmax': tf.VarLenFeature(dtype=tf.float32),\\n 'image/object/bbox/ymax': tf.VarLenFeature(dtype=tf.float32),\\n 'image/object/bbox/label': tf.VarLenFeature(dtype=tf.int64),\\n 'image/object/bbox/difficult': tf.VarLenFeature(dtype=tf.int64),\\n 'image/object/bbox/truncated': tf.VarLenFeature(dtype=tf.int64),\\n }\\n \\n #适配器2：将反序列化的数据组装成更高级的格式。由slim完成\\n items_to_handlers = {\\n 'image': slim.tfexample_decoder.Image('image/encoded', 'image/format'),\\n 'shape': slim.tfexample_decoder.Tensor('image/shape'),\\n 'object/bbox': slim.tfexample_decoder.BoundingBox(\\n ['ymin', 'xmin', 'ymax', 'xmax'], 'image/object/bbox/'),\\n 'object/label': slim.tfexample_decoder.Tensor('image/object/bbox/label'),\\n 'object/difficult': slim.tfexample_decoder.Tensor('image/object/bbox/difficult'),\\n 'object/truncated': slim.tfexample_decoder.Tensor('image/object/bbox/truncated'),\\n }\\n # 解码器\\n decoder = slim.tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers)\\n \\n # dataset对象定义了数据集的文件位置，解码方式等元信息\\n dataset = slim.dataset.Dataset(\\n data_sources=file_pattern,\\n reader=reader,\\n num_samples = SPLITS_TO_SIZES['test'], # 手动生成了三个文件， 每个文件里只包含一个example\\n decoder=decoder,\\n items_to_descriptions = ITEMS_TO_DESCRIPTIONS,\\n num_classes=NUM_CLASSES)\\n return dataset\",\n \"def load_image(path: str):\\n if path.endswith('.npy'):\\n return np.load(path)\\n if path.endswith(('.nii', '.nii.gz', '.hdr', '.img')):\\n import nibabel as nib\\n return nib.load(path).get_data()\\n if path.endswith('.tif'):\\n from PIL import Image\\n with Image.open(path) as image:\\n return np.asarray(image)\\n\\n raise ValueError(f\\\"Couldn't read image from path: {path}.\\\\n\\\"\\n \\\"Unknown file extension.\\\")\",\n \"def loaddata(path):\\n if path.endswith(\\\".tiff\\\") or path.endswith(\\\".tif\\\"):\\n try:\\n from vigra.impex import readVolume\\n except ImportError:\\n raise ImportError(\\\"Vigra is needed to read/write TIFF volumes, but could not be imported.\\\")\\n\\n volume = readVolume(path)\\n return volume\\n\\n elif path.endswith(\\\".h5\\\"):\\n try:\\n from Antipasti.netdatautils import fromh5\\n except ImportError:\\n raise ImportError(\\\"h5py is needed to read/write HDF5 volumes, but could not be imported.\\\")\\n\\n volume = fromh5(path)\\n return volume\\n\\n else:\\n raise NotImplementedError(\\\"Can't load: unsupported format. Supported formats are .tiff and .h5\\\")\",\n \"def __getitem__(self, idx):\\n ImageFile.LOAD_TRUNCATED_IMAGES = True\\n image = Image.open(self.filenames[idx]) # PIL image\\n width, height = image.size\\n if width<IMAGE_SIZE or height<IMAGE_SIZE:\\n image = image.resize((IMAGE_SIZE+50, IMAGE_SIZE+50))\\n \\n image = image.convert('RGB')\\n tensor = self.transform(image)\\n sample = (tensor, self.labels[idx])\\n return sample\",\n \"def _load_image(self, index: int) -> Tensor:\\n path = self.files[index][\\\"image\\\"]\\n with rasterio.open(path) as f:\\n array = f.read()\\n tensor = torch.from_numpy(array).float()\\n return tensor\",\n \"def parse_extension(filepath):\\n extension = os.path.splitext(filepath)[1][1:]\\n\\n extensions_dict = {\\\"netcdf\\\": ['nc'],\\n \\\"mitiff\\\": ['mitiff'],\\n \\\"geotiff\\\": ['gtiff', 'tiff', 'tif']}\\n\\n driver = None\\n\\n for key in extensions_dict:\\n if extension in extensions_dict[key]:\\n driver = key \\n\\n if driver is not None:\\n return driver\\n else:\\n raise Exception(\\\"Unknown file extension, cannot guess file format\\\")\",\n \"def __getitem__(self, idx):\\n label, path = self.pathList[idx]\\n file_list = os.listdir(path)\\n # parse the images in the folder\\n for pt_file in file_list:\\n file_path = path + pt_file\\n extension = os.path.splitext(file_path)[1]\\n\\n # choose only the file that has the tensor weights\\n if extension == '.pt':\\n tensor = torch.load(file_path) # size Nx20x2 because the shape is made of 20 (x,y) tuples\\n \\n # Change type Int to type Float\\n tensor = tensor.type(torch.FloatTensor) # On cpu for now\\n\\n # normalization of the coordinates\\n #tensor[:,:,0] /= 300 # x\\n #tensor[:,:,1] /= 150 # y\\n\\n tensor = tensor.view(tensor.size()[0], 40) # resize to Nx40\\n\\n return tensor, label\",\n \"def __ext_from_image_stream(stream):\\n ext_map = {'GIF': '.gif', 'JPEG': '.jpg', 'PNG': '.png',\\n 'TIFF': '.tiff', 'WMF': '.wmf'}\\n stream.seek(0)\\n format = PIL_Image.open(stream).format\\n if format not in ext_map:\\n tmpl = \\\"unsupported image format, expected one of: %s, got '%s'\\\"\\n raise ValueError(tmpl % (ext_map.keys(), format))\\n return ext_map[format]\",\n \"def get_from_file(self, filename):\\n print \\\"loading from file...\\\"\\n return cv2.imread(filename)\",\n \"def retrieveImageInfo(self, filename):\\t\\t \\n\\t\\tassert filename, \\\"Filename must be defined\\\"\\n\\t\\tassert os.path.exists(filename), \\\"File that we're retrieving information \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfrom (%s) needs to exist, but doesn't.\\\" % filename\\n\\t\\tself.ext = filename.split(\\\".\\\")[-1].lower()\\n\\t\\trdr = self.getReaderByExtension(self.ext)\\n\\t\\t\\n\\t\\tif self.ext == \\\"bmp\\\":\\n\\t\\t\\trdr.Allow8BitBMPOn()\\n\\t\\trdr.SetFileName(filename)\\n\\t\\tif rdr.IsA(\\\"vtkExtTIFFReader\\\"):\\n\\t\\t\\trdr.UpdateInformation()\\n\\t\\t\\tif rdr.GetNumberOfScalarComponents() == 1:\\n\\t\\t\\t\\trdr.RawModeOn()\\n\\n\\t\\tdata = rdr.GetOutput()\\n\\t\\tdata.Update()\\n\\t\\tself.numberOfComponents = data.GetNumberOfScalarComponents()\\n\\n\\t\\tif not self.ctf:\\n\\t\\t\\tbd = self.getDataBitDepth(data)\\n\\t\\t\\tself.ctf = vtk.vtkColorTransferFunction()\\n\\t\\t\\tif bd == 8 or bd == 12:\\n\\t\\t\\t\\tself.ctf.AddRGBPoint(0, 0, 0, 0)\\n\\t\\t\\t\\tself.ctf.AddRGBPoint((2 ** bd) - 1, 0, 1, 0)\\n\\t\\t\\telse:\\n\\t\\t\\t\\trange = data.GetScalarRange()\\n\\t\\t\\t\\tself.ctf.AddRGBPoint(range[0], 0, 0, 0)\\n\\t\\t\\t\\tself.ctf.AddRGBPoint(range[1], 0, 1, 0)\\n\\t\\t\\t\\n\\t\\tself.x, self.y, z = data.GetDimensions()\\n\\t\\tself.dimensions = (self.x, self.y, self.slicesPerTimepoint)\\n\\t\\tif z > 1:\\n\\t\\t\\tself.slicesPerTimepoint = z\\n\\t\\t\\tself.z = z\\n\\t\\t\\tself.dimensions = (self.x, self.y, self.slicesPerTimepoint)\\n\\t\\t\\tlib.messenger.send(self, \\\"update_dimensions\\\")\\n\\t\\tself.originalDimensions = self.dimensions\",\n \"def create(path: Union[Path, str]):\\n if isinstance(path, str):\\n path = Path(path)\\n \\n ext = path.suffix.lower()\\n if ext == \\\".hdr\\\":\\n reader = RadianceHDRFormat.read\\n elif ext == \\\".exr\\\":\\n reader = OpenEXRFormat.read\\n elif ext == \\\".pfm\\\":\\n reader = PFMFormat.read\\n else:\\n # assuming the image is LDR\\n def pil_reader(path: Union[Path, str]) -> np.ndarray:\\n # open path as file to avoid ResourceWarning (https://github.com/python-pillow/Pillow/issues/835)\\n with open(path, 'rb') as f:\\n img = Image.open(f)\\n img = np.asarray(img.convert(\\\"RGB\\\"))\\n if img.dtype.startswith(\\\"uint\\\") or img.dtype.startswith(\\\"int\\\"):\\n info = np.iinfo(img.dtype)\\n elif img.dtype.startswith(\\\"float\\\"):\\n info = np.finfo(img.dtype)\\n else:\\n raise TypeError()\\n\\n min_ = float(info.min)\\n max_ = float(info.max)\\n return min_max_normalization(img.astype(np.float64), min_, max_) \\n reader = pil_reader\\n return reader\",\n \"def read_array(self, filename):\\n extension = filename.split('.')[-1] # Get file extension\\n if extension == 'mat':\\n array = sci.loadmat(filename)\\n elif extension == 'npy':\\n array = np.load(filename)\\n else:\\n print('Error!!! Unrecognised file type for read_array()')\\n array = None\\n return array\",\n \"def nircam_image_reader(file_name):\\n\\n hdulist = fits.open(file_name)\\n data = Data(label='NIRCam Image')\\n data.header = hdulist[0].header\\n wcs = WCS(hdulist[0].header)\\n\\n # drop the last axis since the cube will be split\\n data.coords = coordinates_from_wcs(wcs.sub(2))\\n data.add_component(hdulist[0].data[0], 'Flux')\\n data.add_component(hdulist[0].data[1], 'Uncertainty')\\n\\n return data\",\n \"def load(self,filename):\\n basename = os.path.basename(filename)\\n self.name, ext = os.path.splitext(basename)\\n if ext == '.xml':\\n self.load_xml(filename)\\n elif ext == '.tsv':\\n self.load_tsv_fast(filename)\\n elif ext == '.tsvs':\\n self.load_tsv(filename)\\n else:\\n print 'Error: only .xml and .tsv files are supported'\",\n \"def vF3d_VTK(field,name,VTKformat): \\n if VTKformat == 'vtu':\\n vf3d_vtu(field,name)\\n elif VTKformat == None:\\n print 'Please select a VTK format'\\n else:\\n print 'The selected format has not been developed yet'\\n return #nothing, since functions output the written VTK file\",\n \"def get_loader(csv_file, img_dir, image_size, batch_size, mode='val', dataset='vg'):\\n\\n if dataset == 'VG':\\n \\n transform = transforms.Compose([\\n transforms.Resize(image_size),\\n transforms.RandomHorizontalFlip(),\\n transforms.ToTensor(),\\n transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\\n\\n dataset = GeneratedVGDataset(csv_file, img_dir, transform)\\n else:\\n \\traise Exception(\\\"currently only VG generated images dataset is provided \\\")\\n\\n shuffle = True if mode == 'train' else False\\n \\n data_loader = DataLoader(dataset=dataset, batch_size=batch_size, shuffle=shuffle, num_workers=4)\\n\\n return data_loader\",\n \"def load_volume(name, nx, ny, nz):\\n\\n # load raw volume into memory\\n img = np.fromfile(name, dtype=np.float32)\\n img = np.reshape(img, (ny, nx, nz))\\n\\n return img.transpose(0, 2, 1)\",\n \"def __getitem__(self, t):\\n collection = {}\\n\\n # read raw data and unpack (if necessary)\\n for typ in self.files.keys():\\n scan_data = None\\n if typ == \\\"label\\\":\\n scan_data = np.fromfile(self.files[typ][t], dtype=np.uint16)\\n else:\\n scan_data = unpack(np.fromfile(self.files[typ][t], dtype=np.uint8))\\n\\n # turn in actual voxel grid representation.\\n collection[typ] = scan_data.reshape(VOXEL_DIMS)\\n\\n return self.filenames[t], collection\",\n \"def imgRead(filename: str, representation: int) -> np.ndarray:\\r\\n if representation==LOAD_GRAY_SCALE:\\r\\n img = cv2.imread(filename,0)\\r\\n else:\\r\\n img = cv2.imread(filename)\\r\\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\\r\\n return img.astype('uint8')\",\n \"def _open_image(self, path):\\n return cv.imread(path, 1)\\n # .astype(float)\",\n \"def get_split(split_name, dataset_dir, file_pattern=None, reader=None):\\n\\tif split_name not in SPLITS_TO_SIZES and split_name[:-2] not in SPLITS_TO_SIZES:\\n\\t\\traise ValueError('split name %s was not recognized.' % split_name)\\n\\n\\tif not file_pattern:\\n\\t\\tfile_pattern = _FILE_PATTERN\\n\\tfile_pattern = os.path.join(dataset_dir, file_pattern % split_name)\\n\\t#Allowing None in the signature so that the dataset_factory can use the default\\n\\tif reader is None:\\n\\t\\treader = tf.TFRecordReader\\n\\n\\tkeys_to_features = {\\n\\t\\t'image/encoded': tf.FixedLenFeature(\\n\\t\\t\\t(), tf.string, default_value=''),\\n\\t\\t'image/format': tf.FixedLenFeature(\\n\\t\\t\\t(), tf.string, default_value='jpeg'),\\n\\t\\t'image/class/label': tf.FixedLenFeature(\\n\\t\\t\\t[], tf.int64, default_value=tf.zeros([], dtype=tf.int64)),\\n\\t}\\n\\titems_to_handlers = {\\n\\t\\t'image': slim.tfexample_decoder.Image(),\\n\\t\\t'label': slim.tfexample_decoder.Tensor('image/class/label'),\\n\\t}\\n\\n\\tdecoder = slim.tfexample_decoder.TFExampleDecoder(\\n\\t\\tkeys_to_features, items_to_handlers)\\n\\n\\tlabels_to_names = None\\n\\tif dataset_utils.has_labels(dataset_dir):\\n\\t\\tlabels_to_names=dataset_utils.read_label_file(dataset_dir)\\n\\t\\n\\tif split_name in SPLITS_TO_SIZES:\\n\\t\\tnum_samples = SPLITS_TO_SIZES[split_name]\\n\\telif split_name[:-2] in SPLITS_TO_SIZES:\\n\\t\\tnum_samples = SPLITS_TO_SIZES[split_name[:-2]]\\n\\n\\treturn slim.dataset.Dataset(data_sources=file_pattern,\\n\\t\\treader=reader,\\n\\t\\tdecoder=decoder,\\n\\t\\tnum_samples=num_samples,\\n\\t\\titems_to_descriptions=_ITEMS_TO_DESCRIPTIONS,\\n\\t\\tnum_classes=_NUM_CLASSES,\\n\\t\\tlabels_to_names=labels_to_names)\",\n \"def file_reader(image_file, label_file):\\n\\n image = im.imread(image_file)\\n\\n with open(label_file, \\\"r\\\") as file:\\n label = float(file.read())\\n\\n return image, label\",\n \"def get_itk_image(path):\\n\\n reader = itk.ImageFileReader()\\n reader.SetFileName(path)\\n\\n image = reader.Execute()\\n\\n return image\",\n \"def get_split(split_name, dataset_dir, file_pattern=None, reader=None):\\n\\tif split_name not in _SPLITS_TO_SIZES:\\n\\t\\traise ValueError(\\\"split name %s was not recognized.\\\" % split_name)\\n\\tif not file_pattern:\\n\\t\\tfile_pattern = _FILE_PATTERN\\n\\tfile_pattern = os.path.join(dataset_dir, file_pattern % split_name)\\n\\tif reader is None:\\n\\t\\treader = tf.TFRecordReader\\n\\tkeys_to_features = {\\\"image/encoded\\\": tf.FixedLenFeature((), tf.string, default_value=\\\"\\\"), \\\"image/format\\\": tf.FixedLenFeature((), tf.string, default_value=\\\"png\\\"), \\\"image/class/label\\\": tf.FixedLenFeature([1], tf.int64, default_value=tf.zeros([1], dtype=tf.int64))}\\n\\titems_to_handlers = {\\\"image\\\": slim.tfexample_decoder.Image(shape=[32, 32, 3], channels=3), \\\"label\\\": slim.tfexample_decoder.Tensor(\\\"image/class/label\\\", shape=[])}\\n\\tdecoder = slim.tfexample_decoder.TFExampleDecoder(keys_to_features, items_to_handlers)\\n\\tlabels_to_names = None\\n\\tif dataset_utils.has_labels(dataset_dir):\\n\\t\\tlabels_to_names = dataset_utils.read_label_file(dataset_dir)\\n\\treturn slim.dataset.Dataset(data_sources=file_pattern, reader=reader, decoder=decoder, num_samples=_SPLITS_TO_SIZES[split_name], num_classes=_NUM_CLASSES, items_to_descriptions=_ITEMS_TO_DESCRIPTIONS, labels_to_names=labels_to_names)\",\n \"def import_grid(file_name):\\n\\n return FileReader(file_name=file_name).grid\",\n \"def LoadMetadata(filename):\\r\\n## print filename\\r\\n globbed=glob.glob(os.path.join(os.path.dirname(filename),'*.zvi'))\\r\\n if globbed:\\r\\n return LoadZVIMetaData(globbed[0])\\r\\n globbed=glob.glob(os.path.join(os.path.dirname(filename),'*.xml'))\\r\\n if globbed:\\r\\n return LoadAxioVisionXMLMetaData(globbed[0])\\r\\n globbed=glob.glob(os.path.join(os.path.dirname(filename),'metadata.txt'))\\r\\n if globbed:\\r\\n return LoadMMMetaData(globbed[0])\\r\\n return None\\r\\n #no further valid options, crash horribly\\r\",\n \"def load_faces(path, ext=\\\".pgm\\\"):\\n \\n #\\n # You code here\\n #\\n \\n images = []\\n img_shape = (0, 0)\\n\\n for root, dirs, files in os.walk(path):\\n for file in files:\\n if ext in file: # check if file is of pgm-type\\n img_path = os.path.join(root, file)\\n img = plt.imread(img_path) # Read the image\\n img_shape = img.shape\\n img = img.flatten() # Transform 2D image into vector M = height x width\\n images.append(img)\\n\\n img_array = np.asarray(images) \\n\\n return img_array, img_shape\",\n \"def get_input(path):\\n img = imread(path)\\n return img\",\n \"def driver_from_file(input_file: str, quick: bool = True) -> str:\\n input_file = MPath.from_inp(input_file)\\n\\n # mapchete files can immediately be returned:\\n if input_file.suffix == \\\".mapchete\\\":\\n return \\\"Mapchete\\\"\\n\\n # use the most common file extensions to quickly determine input driver for file:\\n if quick:\\n try:\\n return driver_from_extension(input_file.suffix)\\n except ValueError:\\n pass\\n\\n # brute force by trying to open file with rasterio and fiona:\\n try:\\n logger.debug(\\\"try to open %s with rasterio...\\\", input_file)\\n with rasterio_open(input_file): # pragma: no cover\\n return \\\"raster_file\\\"\\n except Exception as rio_exception:\\n try:\\n logger.debug(\\\"try to open %s with fiona...\\\", input_file)\\n with fiona_open(input_file): # pragma: no cover\\n return \\\"vector_file\\\"\\n except Exception as fio_exception:\\n if input_file.exists():\\n logger.exception(f\\\"fiona error: {fio_exception}\\\")\\n logger.exception(f\\\"rasterio error: {rio_exception}\\\")\\n raise MapcheteDriverError(\\n \\\"%s has an unknown file extension and could not be opened by neither \\\"\\n \\\"rasterio nor fiona.\\\" % input_file\\n )\\n else:\\n raise FileNotFoundError(\\\"%s does not exist\\\" % input_file)\",\n \"def read(dataset = \\\"training\\\", path = \\\".\\\"):\\n\\n if dataset is \\\"training\\\":\\n fname_img = os.path.join(path, 'train-images.idx3-ubyte')\\n fname_lbl = os.path.join(path, 'train-labels.idx1-ubyte')\\n elif dataset is \\\"testing\\\":\\n fname_img = os.path.join(path, 't10k-images.idx3-ubyte')\\n fname_lbl = os.path.join(path, 't10k-labels.idx1-ubyte')\\n else:\\n raise ValueError(\\\"dataset must be 'testing' or 'training'\\\")\\n\\n # Load everything in some numpy arrays\\n with open(fname_lbl, 'rb') as flbl:\\n magic, num = struct.unpack(\\\">II\\\", flbl.read(8))\\n lbl = np.fromfile(flbl, dtype=np.int8)\\n\\n with open(fname_img, 'rb') as fimg:\\n magic, num, rows, cols = struct.unpack(\\\">IIII\\\", fimg.read(16))\\n img = np.fromfile(fimg, dtype=np.uint8).reshape(len(lbl), rows, cols)\\n\\n get_img = lambda idx: (lbl[idx], img[idx])\\n\\n # Create an iterator which returns each image in turn\\n for i in range(len(lbl)):\\n yield get_img(i)\",\n \"def read_image(filename, representation):\\n img = imread(filename)\\n img = int2float(img)\\n if representation == GS_REP:\\n img = rgb2gray(img)\\n return img\",\n \"def file_type(filepath):\\n imexts = ['.png', '.bmp', '.jpg', 'jpeg']\\n textexts = ['.csv', '.txt']\\n if filepath.endswith('.hdf5') or filepath.endswith('.h5'):\\n return 'hdf5'\\n if any([filepath.endswith(ext) for ext in textexts]):\\n return 'delim'\\n if filepath.endswith('.grm.raw'):\\n return 'grm.raw'\\n if filepath.endswith('.npy'):\\n return 'npy'\\n if _is_bed(filepath):\\n return 'bed'\\n if _is_gen(filepath):\\n return 'gen'\\n if any([filepath.endswith(ext) for ext in imexts]):\\n return 'image'\\n return 'unknown'\",\n \"def read(filename, ext=None, extver=None, columns=None, rows=None,\\n header=False, case_sensitive=False, upper=False, lower=False,\\n vstorage='fixed', verbose=False, trim_strings=False, **keys):\\n\\n if keys:\\n import warnings\\n warnings.warn(\\n \\\"The keyword arguments '%s' are being ignored! This warning \\\"\\n \\\"will be an error in a future version of `fitsio`!\\\" % keys,\\n DeprecationWarning, stacklevel=2)\\n\\n kwargs = {\\n 'lower': lower,\\n 'upper': upper,\\n 'vstorage': vstorage,\\n 'case_sensitive': case_sensitive,\\n 'verbose': verbose,\\n 'trim_strings': trim_strings\\n }\\n\\n read_kwargs = {}\\n if columns is not None:\\n read_kwargs['columns'] = columns\\n if rows is not None:\\n read_kwargs['rows'] = rows\\n\\n with FITS(filename, **kwargs) as fits:\\n\\n if ext is None:\\n for i in xrange(len(fits)):\\n if fits[i].has_data():\\n ext = i\\n break\\n if ext is None:\\n raise IOError(\\\"No extensions have data\\\")\\n\\n item = _make_item(ext, extver=extver)\\n\\n data = fits[item].read(**read_kwargs)\\n if header:\\n h = fits[item].read_header()\\n return data, h\\n else:\\n return data\",\n \"def openFile(dir):\\n # If path is a directory\\n if os.path.isdir(dir):\\n # Check file sizes from first file\\n Nt = len(glob.glob(dir + \\\"/1_*.txt\\\")) # Nt\\n tmp = np.loadtxt(dir + \\\"/1_0.txt\\\") \\n Ny, Nx = tmp.shape\\n # Output array\\n V = np.zeros((Nt, 2, Ny, Nx))\\n for n in range(Nt):\\n V1 = np.loadtxt(\\\"{0}/1_{1}.txt\\\".format(dir, n))\\n V2 = np.loadtxt(\\\"{0}/2_{1}.txt\\\".format(dir, n))\\n V[n] = V1, V2\\n return V\\n # If path is a file\\n elif os.path.isfile(dir):\\n if '.npy' in dir: # Numpy data file\\n return np.load(dir)\\n elif '.txt' in dir: # Plain text data file\\n return np.loadtxt(dir)\\n else:\\n raise Exception(\\\"File extension not supported.\\\")\\n else:\\n raise Exception(\\\"Path is not supported.\\\")\",\n \"def _openFlt(self, fname):\\n image = np.loadtxt(fname)\\n\\n if(image !=None):\\n M,N=(int(image[0]), int(image[1]))\\n image = image[2:image.shape[0]]\\n image = image.reshape((M,N))\\n else:\\n raise IOError, \\\"Image file can not be opened\\\"\\n\\n return image\",\n \"def read_image(fname, roi=None, dset_name='default', parallelism=1):\\n\\n from functools import partial\\n from numpy import array, ndarray\\n from multiprocessing import Pool, cpu_count\\n\\n if isinstance(fname, str):\\n fmt = fname.split('.')[-1]\\n \\n if fmt == '.h5' or fmt == '.hdf5':\\n reader = partial(readers[fmt], roi=roi, dset_name=dset_name)\\n else:\\n reader = partial(readers[fmt], roi=roi)\\n \\n result = reader(fname)\\n\\n elif isinstance(fname, (tuple, list, ndarray)):\\n fmt = fname[0].split('.')[-1]\\n if fmt == '.h5' or fmt == '.hdf5':\\n reader = partial(readers[fmt], roi=roi, dset_name=dset_name)\\n else:\\n reader = partial(readers[fmt], roi=roi)\\n\\n if parallelism == 1:\\n result = array([reader(f) for f in fname])\\n\\n else:\\n if parallelism == -1:\\n num_cores = cpu_count()\\n else:\\n num_cores = min(parallelism, cpu_count())\\n\\n with Pool(num_cores) as pool:\\n result = array(pool.map(reader, fname))\\n else:\\n raise TypeError(\\n \\\"First argument must be string for a one file or (tuple, list, ndarray) for many files\\\"\\n )\\n\\n return result\",\n \"def _load(self, pkgpart, part_dict):\\n # call parent to do generic aspects of load\\n super(Image, self)._load(pkgpart, part_dict)\\n # set file extension\\n self.__ext = posixpath.splitext(pkgpart.partname)[1]\\n # return self-reference to allow generative calling\\n return self\",\n \"def loadFile(filterExt):\\n basicFilter = \\\"*.\\\" + filterExt\\n filePath = fileDialog2(fileFilter=basicFilter, dialogStyle=2, fm=1)\\n if(filePath != None):\\n #openfile = open('/Users/camtton/Desktop/drawing.svg', 'r')\\n tokens = getSVGpath(filePath[0])\\n return tokens\\n else:\\n print 'Please select a %s file'%(filterExt)\",\n \"def __init__(self, filepath: str):\\n self.filetype: str = filepath[len(filepath) - 3:].upper()\\n self.tags = None\\n self.locations: [Location] = None\\n self.intermediaryImage = None\\n self.outlined = None\\n if self.filetype == 'TIF':\\n print('found tif')\\n with TiffFile(filepath) as tif:\\n # fileInfo(tif)\\n self.tags = metadataGeoTags(tif)\\n self.image = tif.asarray()\\n elif self.filetype == 'PNG' or self.filetype == 'JPG':\\n print('found png')\\n self.image = cv2.imread(filepath, cv2.IMREAD_UNCHANGED)\\n else:\\n print('invalid file type:', self.filetype)\",\n \"def get_infile(filename):\\r\\n if filename.endswith(\\\".gz\\\"):\\r\\n fin = GzipFile(filename, \\\"rb\\\")\\r\\n else:\\r\\n fin = open(filename, \\\"U\\\")\\r\\n return fin\",\n \"def get_infile(filename):\\r\\n if filename.endswith(\\\".gz\\\"):\\r\\n fin = GzipFile(filename, \\\"rb\\\")\\r\\n else:\\r\\n fin = open(filename, \\\"U\\\")\\r\\n return fin\",\n \"def img_read(name):\\n\\n img = cv2.imread(name)\\n\\n return img\",\n \"def get_split(split_name, dataset_dir, file_pattern=None, reader=None):\\n if split_name not in SPLITS_TO_SIZES:\\n raise ValueError('split name %s was not recognized.' % split_name)\\n\\n if not file_pattern:\\n file_pattern = _FILE_PATTERN\\n file_pattern = os.path.join(dataset_dir, file_pattern % split_name)\\n\\n # Allowing None in the signature so that dataset_factory can use the default.\\n if not reader:\\n reader = tf.TFRecordReader\\n\\n keys_to_features = {\\n 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''),\\n 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpg'),\\n 'image/class/label': tf.FixedLenFeature(\\n [], tf.int64, default_value=tf.zeros([], dtype=tf.int64)),\\n 'image/height': tf.FixedLenFeature(\\n [], tf.int64, default_value=tf.zeros([], dtype=tf.int64)),\\n 'image/width':tf.FixedLenFeature(\\n [], tf.int64, default_value=tf.zeros([], dtype=tf.int64)), \\n }\\n\\n items_to_handlers = {\\n 'image': slim.tfexample_decoder.Image(),\\n 'label': slim.tfexample_decoder.Tensor('image/class/label'),\\n 'height': slim.tfexample_decoder.Tensor('image/height'),\\n 'width': slim.tfexample_decoder.Tensor('image/width'),\\n \\n }\\n\\n decoder = slim.tfexample_decoder.TFExampleDecoder(\\n keys_to_features, items_to_handlers)\\n\\n labels_to_names = None\\n if dataset_utils.has_labels(dataset_dir):\\n labels_to_names = dataset_utils.read_label_file(dataset_dir)\\n\\n return slim.dataset.Dataset(\\n data_sources=file_pattern,\\n reader=reader,\\n decoder=decoder,\\n num_samples=SPLITS_TO_SIZES[split_name],\\n num_classes=2,\\n items_to_descriptions=_ITEMS_TO_DESCRIPTIONS,\\n labels_to_names=labels_to_names)\",\n \"def load_file(path='vgg19.mat'):\\n\\t\\tfile=loadmat(path)\\n\\t\\tfile=file['layers']\\n\\t\\tprint(\\\"Success load_file\\\")\\n\\t\\treturn file\",\n \"def _load(f, as_gray=False):\\n # importing io is quite slow since it scans all the backends\\n # we lazy import it here\\n from skimage.io import imread\\n return imread(os.path.join(data_dir, f), plugin='pil', as_gray=as_gray)\",\n \"def im_open(path):\\n\\n try:\\n assert os.path.isdir(path)\\n #get file list in directory - glob includes full path\\n files = sorted(glob.glob('{}{}*'.format(path,os.sep)), key=sort_key) \\n #load the collection\\n raw_stack = io.imread_collection(files)\\n #turn the collection into a np array and remove extraneous OCT portion from 1025:1083 on x axis. (z,y,x)\\n #if .bmp files are open (from pv-oct), the slicing will not affect them, the x-axis is only 540 pixels.\\n stack = io.collection.concatenate_images(raw_stack)[:,:,0:1024]\\n \\n return stack\\n\\n except AssertionError:\\n sys.exit(\\\"A non-directory object was given to the __open__ function\\\")\",\n \"def get_file_type(file_path):\\n ext = pathlib.Path(file_path).suffix\\n return \\\"video\\\" if ext == \\\".avi\\\" else \\\"image\\\"\",\n \"def loadFromFile(cls , filename):\\n if FortIO.isFortranFile( filename ):\\n return EclGrid( filename )\\n else:\\n return EclGrid.loadFromGrdecl( filename )\",\n \"def render_vtk(file_name):\\n import vtk\\n\\n # Read the source file.\\n reader = vtk.vtkUnstructuredGridReader()\\n reader.SetFileName(file_name)\\n reader.Update() # Needed because of GetScalarRange\\n output = reader.GetOutput()\\n scalar_range = output.GetScalarRange()\\n\\n # Create the mapper that corresponds the objects of the vtk.vtk file\\n # into graphics elements\\n mapper = vtk.vtkDataSetMapper()\\n mapper.SetInputData(output)\\n mapper.SetScalarRange(scalar_range)\\n\\n # Create the Actor\\n actor = vtk.vtkActor()\\n actor.SetMapper(mapper)\\n\\n # Create the Renderer\\n renderer = vtk.vtkRenderer()\\n renderer.AddActor(actor)\\n renderer.SetBackground(1, 1, 1) # Set background to white\\n\\n # Create the RendererWindow\\n renderer_window = vtk.vtkRenderWindow()\\n renderer_window.AddRenderer(renderer)\\n\\n # Create the RendererWindowInteractor and display the vtk_file\\n interactor = vtk.vtkRenderWindowInteractor()\\n interactor.SetRenderWindow(renderer_window)\\n interactor.Initialize()\\n interactor.Start()\",\n \"def dispatch_loader(fname, direc, sep=\\\"\\\\t\\\"):\\n ext = fname.split(\\\".\\\")[-1]\\n # print('Loading from: {}/{}'.format(direc, fname))\\n if ext in (\\\"tsv\\\" or \\\"txt\\\"):\\n return load_df_from_txt(fname, direc, sep)\\n elif ext == \\\"pkl\\\":\\n return load_df_from_pkl(fname, direc)\\n else:\\n raise IOError(\\\"Unexpected file extension {}.\\\".format(ext))\",\n \"def __init__(self, fits_file, ext=0):\",\n \"def read(dataset = \\\"training\\\", path = \\\".\\\"):\\n\\n if dataset is \\\"training\\\":\\n fname_img = os.path.join(path, 'train-images-idx3-ubyte')\\n fname_lbl = os.path.join(path, 'train-labels-idx1-ubyte')\\n elif dataset is \\\"testing\\\":\\n fname_img = os.path.join(path, 't10k-images-idx3-ubyte')\\n fname_lbl = os.path.join(path, 't10k-labels-idx1-ubyte')\\n else:\\n raise ValueError, \\\"dataset must be 'testing' or 'training'\\\"\\n\\n # Load everything in some numpy arrays\\n with open(fname_lbl, 'rb') as flbl:\\n magic, num = struct.unpack(\\\">II\\\", flbl.read(8))\\n lbl = np.fromfile(flbl, dtype=np.int8)\\n\\n with open(fname_img, 'rb') as fimg:\\n magic, num, rows, cols = struct.unpack(\\\">IIII\\\", fimg.read(16))\\n img = np.fromfile(fimg, dtype=np.uint8).reshape(len(lbl), rows, cols)\\n\\n get_img = lambda idx: (lbl[idx], img[idx])\\n\\n # Create an iterator which returns each image in turn\\n for i in xrange(len(lbl)):\\n yield get_img(i)\",\n \"def imread(filename, *args, **kwargs):\\r\\n try:\\r\\n netpbm = NetpbmFile(filename)\\r\\n image = netpbm.asarray()\\r\\n finally:\\r\\n netpbm.close()\\r\\n return image\",\n \"def image_loader(fileobj):\\n if isinstance(fileobj, six.string_types):\\n return cv2.imread(fileobj, cv2.IMREAD_COLOR)[..., ::-1] #bgr->rgb\\n elif isinstance(fileobj, bytes):\\n byte_arr = bytearray(fileobj)\\n else:\\n byte_arr = bytearray(fileobj.read())\\n \\n return cv2.imdecode(np.asarray(byte_arr, dtype=np.uint8), cv2.IMREAD_COLOR)[..., ::-1] #bgr->rgb\",\n \"def loader(path):\\n img = np.load(path)\\n img = img[1:4]\\n if np.random.choice((True, False)):\\n img = img[:, :, ::-1]\\n img = np.array(img)\\n if np.random.choice((True, False)):\\n img = img[:, ::-1, :]\\n img = np.array(img)\\n\\n img = img.transpose((1, 2, 0)) # pytorch is going to rotate it back\\n return img\",\n \"def read_image(self, item):\\n assert item['image_dtype'] == 'uint16'\\n\\n filename = os.path.join(self.home(item['basename']))\\n s = open(filename, 'rb').read()\\n assert hashlib.md5(s).hexdigest() == item['md5']\\n img = np.fromstring(s, dtype=item['image_dtype']).byteswap()\\n img = img.reshape(item['image_shape'])\\n return img\",\n \"def read_file(path: str, flag: bool, size=224):\\n img_path = sorted(os.listdir(path))\\n img_num = len(img_path)\\n img_data = np.zeros((img_num, 224, 224, 3), dtype=np.uint8)\\n img_label = np.zeros(img_num, dtype=np.uint8)\\n for lps, no in enumerate(img_path):\\n img = cv2.imread(os.path.join(path, no))\\n img_data[lps, :, :] = cv2.resize(img, (224, 224))\\n if flag:\\n img_label[lps] = int(no.split(\\\"_\\\")[0])\\n if flag:\\n return img_data, img_label\\n else:\\n return img_data\",\n \"def __getitem__(self, idx):\\n im = Image.open(self.data_path + self.sample_df.loc[idx,'filename'])\\n # load label\\n label = torch.tensor(self.sample_df.loc[idx,'abnormal_XR'])\\n # load mask\\n if self.load_mask:\\n mask = Image.open(self.data_path + self.sample_df.loc[idx,'mask_filename'])\\n else:\\n mask = None\\n\\n # load semi-label\\n if self.load_semilabels:\\n semi_label = torch.tensor(self.sample_df.loc[idx, 'semi_label'])\\n else:\\n semi_label = None\\n\\n im, mask = self.transform(im, mask)\\n\\n return im, label, mask, semi_label, torch.tensor(idx)\",\n \"def load_metaimage(path, voxel=True):\\n\\n meta = SimpleITK.ReadImage(path)\\n\\n if voxel:\\n voxel_data = SimpleITK.GetArrayFromImage(meta)\\n meta = [voxel_data, meta]\\n\\n return meta\",\n \"def tiffread(f):\\n if type(f) is str:\\n # single image\\n im = tf.imread(f)\\n return im\\n\\n elif type(f) is list and len(f) == 3:\\n # return rgb stack\\n f.sort(reverse=True) # so r, g, b\\n ims = [tf.imread(x) for x in f]\\n return np.dstack(ims)\\n else:\\n raise ValueError(\\\"f must be a string or list of 3 strings\\\")\",\n \"def read(path: Union[Path, str]) -> np.ndarray:\\n return _reader.imread(str(path))\",\n \"def read(fname, fmt=None):\\n if not fmt:\\n fmt = fname.split(\\\".\\\")[-1]\\n\\n if fmt in ['yml', 'yaml']:\\n return _storage_read(fname, yaml.safe_load)\\n elif fmt == \\\"json\\\":\\n return _storage_read(fname, json.load)\\n elif fmt == \\\"pickle\\\":\\n return _storage_read(fname, pickle.load, 'rb')\\n else:\\n raise Exception()\",\n \"def __getitem__(self, idx):\\n\\n image = Image.open(self.filenames[idx])\\n image = self.transform(image)\\n\\n return image, self.labels[idx]\",\n \"def _get_img_tensor(self, fname, internal_transform):\\n transforms = list(self.base_transforms)\\n if internal_transform:\\n transforms.insert(1, internal_transform)\\n\\n return T.Compose(transforms)(Image.open(self.imgs_root / fname))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64241487","0.5978514","0.59677935","0.5905505","0.5868323","0.5654292","0.5641504","0.5602225","0.5563264","0.55544156","0.55478626","0.55258757","0.5498806","0.54907084","0.5490219","0.5475998","0.5461645","0.5444304","0.54409236","0.541251","0.5400047","0.53965837","0.5396306","0.5388983","0.5361113","0.5355787","0.53399056","0.5339533","0.5339176","0.5320629","0.53079545","0.53033334","0.529854","0.52977824","0.5296988","0.52954155","0.526601","0.5261992","0.52300787","0.521139","0.5209631","0.5209493","0.5188725","0.51776206","0.51772445","0.5173592","0.51719373","0.515757","0.515743","0.51536745","0.51271236","0.5125388","0.51247317","0.512316","0.51221216","0.5111944","0.5109721","0.51094437","0.5104292","0.51030254","0.5094585","0.5091795","0.50719583","0.5065389","0.5054199","0.50478184","0.5045613","0.5020838","0.5014986","0.5004078","0.5004003","0.4996389","0.49843624","0.4983675","0.49824637","0.4981559","0.4981559","0.4972791","0.49643743","0.4948976","0.49402356","0.493676","0.4936308","0.49346223","0.49320468","0.49287787","0.49278852","0.4927464","0.4920612","0.49205703","0.49187043","0.4910923","0.4907226","0.49006066","0.4895799","0.48946625","0.48905966","0.48880735","0.48825547","0.48809218"],"string":"[\n \"0.64241487\",\n \"0.5978514\",\n \"0.59677935\",\n \"0.5905505\",\n \"0.5868323\",\n \"0.5654292\",\n \"0.5641504\",\n \"0.5602225\",\n \"0.5563264\",\n \"0.55544156\",\n \"0.55478626\",\n \"0.55258757\",\n \"0.5498806\",\n \"0.54907084\",\n \"0.5490219\",\n \"0.5475998\",\n \"0.5461645\",\n \"0.5444304\",\n \"0.54409236\",\n \"0.541251\",\n \"0.5400047\",\n \"0.53965837\",\n \"0.5396306\",\n \"0.5388983\",\n \"0.5361113\",\n \"0.5355787\",\n \"0.53399056\",\n \"0.5339533\",\n \"0.5339176\",\n \"0.5320629\",\n \"0.53079545\",\n \"0.53033334\",\n \"0.529854\",\n \"0.52977824\",\n \"0.5296988\",\n \"0.52954155\",\n \"0.526601\",\n \"0.5261992\",\n \"0.52300787\",\n \"0.521139\",\n \"0.5209631\",\n \"0.5209493\",\n \"0.5188725\",\n \"0.51776206\",\n \"0.51772445\",\n \"0.5173592\",\n \"0.51719373\",\n \"0.515757\",\n \"0.515743\",\n \"0.51536745\",\n \"0.51271236\",\n \"0.5125388\",\n \"0.51247317\",\n \"0.512316\",\n \"0.51221216\",\n \"0.5111944\",\n \"0.5109721\",\n \"0.51094437\",\n \"0.5104292\",\n \"0.51030254\",\n \"0.5094585\",\n \"0.5091795\",\n \"0.50719583\",\n \"0.5065389\",\n \"0.5054199\",\n \"0.50478184\",\n \"0.5045613\",\n \"0.5020838\",\n \"0.5014986\",\n \"0.5004078\",\n \"0.5004003\",\n \"0.4996389\",\n \"0.49843624\",\n \"0.4983675\",\n \"0.49824637\",\n \"0.4981559\",\n \"0.4981559\",\n \"0.4972791\",\n \"0.49643743\",\n \"0.4948976\",\n \"0.49402356\",\n \"0.493676\",\n \"0.4936308\",\n \"0.49346223\",\n \"0.49320468\",\n \"0.49287787\",\n \"0.49278852\",\n \"0.4927464\",\n \"0.4920612\",\n \"0.49205703\",\n \"0.49187043\",\n \"0.4910923\",\n \"0.4907226\",\n \"0.49006066\",\n \"0.4895799\",\n \"0.48946625\",\n \"0.48905966\",\n \"0.48880735\",\n \"0.48825547\",\n \"0.48809218\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75270355"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94985,"cells":{"query":{"kind":"string","value":"create the reader list from a given set of file names and parameters"},"document":{"kind":"string","value":"def getReadersFromFilenames(self):\n\t\tfor i in self.readers:\n\t\t\tdel i\n\t\tself.readers = []\n\n\t\tif not self.filenames:\n\t\t\traise Logging.GUIError(\"No files could be found\", \\\n\t\t\t\t\t\t\t\t\t\"For some reason, no files were listed to be imported.\")\t\t \n\t\t\t\t\t\n\t\tfiles = self.filenames\n\t\tprint \"Determining readers from \", self.filenames\n\n\t\tisRGB = 1\n\t\tself.ext = files[0].split(\".\")[-1].lower()\n\t\tdim = self.dimMapping[self.ext]\n\t\t# Initially flip the image if it's tiff, png or jpg.\n\t\t# In setVerticalFlip we negate the setting to have it set correctly.\n\t\tif self.ext.lower() in [\"png\", \"jpg\", \"jpeg\"]:\n\t\t\tself.flipVertically = True\n\t\tif self.ext in [\"tif\", \"tiff\"]:\n\t\t\treader = vtkbxd.vtkExtTIFFReader()\n\t\t\treader.SetFileName(files[0])\n\t\t\treader.UpdateInformation()\n\t\t\tif reader.GetNumberOfScalarComponents() >= 3:\n\t\t\t\tprint \"MODE IS RGB, IS AN RGB IMAGE\"\n\t\t\telse:\n\t\t\t\tprint \"MODE ISN'T RGB, THEREFORE NOT RGB\"\n\t\t\t\tisRGB = 0\n\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\trdr.SetFileName(files[0])\n\t\t\tif rdr.GetNumberOfSubFiles() > 1:\n\t\t\t\tdim = 3\n\t\t\t\t\n\t\tself.isRGB = isRGB\n\t\tself.is3D = (dim == 3)\n\t\t\n\t\tdirName = os.path.dirname(files[0])\n\t\tprint \"THERE ARE\", self.slicesPerTimepoint, \"SLICES PER TIMEPOINT\"\n\t\tself.ext = files[0].split(\".\")[-1].lower()\n\t\t\n\t\tif dim == 3:\n\t\t\ttotalFiles = len(files)\n\t\t\tfor i, file in enumerate(files):\n\t\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\t\trdr.SetFileName(file)\n\t\t\t\tself.readers.append(rdr)\n\t\t\treturn\n\t\t\t\n\t\ttotalFiles = len(files) / self.slicesPerTimepoint\n\n\t\timgAmnt = len(files)\n\t\tif totalFiles == 1:\n\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\tarr = vtk.vtkStringArray()\n\t\t\tfor fileName in files:\n\t\t\t\tarr.InsertNextValue(os.path.join(dirName, fileName))\n\t\t\trdr.SetFileNames(arr)\n\t\t\tself.readers.append(rdr)\n\t\t\treturn\n\t\t\t\n\t\tif imgAmnt > 1:\n\t\t\t# If the pattern doesn't have %, then we just use\n\t\t\t# the given filenames and allocate them to timepoints\n\t\t\t# using slicesPerTimepoint slices per timepoint\n\t\t\tntps = len(files) / self.slicesPerTimepoint\n\t\t\tfilelst = files[:]\n\t\t\t# dirn #TODO: what was this?\n\t\t\tfor tp in range(0, ntps):\n\t\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\t\tarr = vtk.vtkStringArray()\n\t\t\t\tfor i in range(0, self.slicesPerTimepoint):\n\t\t\t\t\tarr.InsertNextValue(filelst[0])\n\t\t\t\t\tfilelst = filelst[1:]\n\t\t\t\trdr.SetFileNames(arr)\n\t\t\t\trdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0, self.slicesPerTimepoint - 1)\n\t\t\t\trdr.SetDataSpacing(self.spacing)\n\t\t\t\trdr.SetDataOrigin(0, 0, 0)\n\t\t\t\tself.readers.append(rdr)\n\t\t\treturn\n\t\t\n\t\telif imgAmnt == 1:\n\t\t\t# If only one file\n\t\t\trdr = self.getReaderByExtension(self.ext, isRGB)\n\t\t\trdr.SetDataExtent(0, self.x - 1, 0, self.y - 1, 0, self.slicesPerTimepoint - 1)\n\t\t\trdr.SetDataSpacing(self.spacing)\n\t\t\trdr.SetDataOrigin(0, 0, 0)\n\t\t\trdr.SetFileName(files[0])\n\n\t\t\tLogging.info(\"Reader = \", rdr, kw = \"io\")\n\t\t\tself.readers.append(rdr)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def initialize_file_readers():\n savefile_path = os.path.join(os.getcwd()+ \"/../data/\", SAVE_FILE)\n file_reader_list = []\n for file in os.listdir(savefile_path):\n file_reader = open(os.path.join(savefile_path,file), \"r\")\n file_reader_list.append({\"file_reader\": file_reader, \"last_read\": { \"word\": \"\", \"doc_score_list\": []}})\n return file_reader_list","def get_file_list(params):\n if params['mode'] == 'test':\n create_file_list(params)\n\n with open(params['file_list']) as flist:\n full_lines = [line.strip() for line in flist]\n\n full_lines = shuffle_lines(full_lines, params[\"shuffle_seed\"])\n\n # use only partial data for each trainer in distributed training\n if params['mode'] == 'train':\n real_trainer_num = max(trainers_num, 1)\n img_per_trainer = len(full_lines) // real_trainer_num\n full_lines = full_lines[trainer_id::real_trainer_num][:img_per_trainer]\n\n return full_lines","def __init__(self, files):\n self.files = files and [NamedFile(data=d, filename=fn) for (d, fn) in files]","def _load_seqs(file_format, filename, fmt, kw, parser_kw):\n fmt = fmt or file_format\n if not fmt:\n msg = \"could not determined file format, set using the format argument\"\n raise ValueError(msg)\n parser_kw = parser_kw or {}\n for other_kw in (\"constructor_kw\", \"kw\"):\n other_kw = kw.pop(other_kw, None) or {}\n kw.update(other_kw)\n return list(FromFilenameParser(filename, fmt, **parser_kw))","def _read(self, file_paths: List[str], **read_opts) -> List[DataFrame]:\n return [read_file(file_path, **read_opts) for file_path in file_paths]","def MFileReader(fvcom, *args, **kwargs):\n\n if isinstance(fvcom, str):\n FVCOM = FileReader(fvcom, *args, **kwargs)\n else:\n for file in fvcom:\n if file == fvcom[0]:\n FVCOM = FileReader(file, *args, **kwargs)\n else:\n FVCOM += FileReader(file, *args, **kwargs)\n\n return FVCOM","def read_data_files(filenames, datapath, ids=None):\n filenames = np.array(filenames) # make sure it's array\n if ids is None:\n ids = range(0, len(filenames))\n\n for i in [filenames[k] for k in ids]:\n yield str(open(datapath+i, 'r').read())","def files_constructor(cmd_args, file_type):\n\n if file_type == 'learning':\n learning_files_list = [LearningFile(address, cmd_args.primary_selex_sequence) for address in cmd_args.learning_file_list]\n [learning_files_list[i].cycle_matrix(i, len(learning_files_list)) for i in range(len(learning_files_list))]\n return learning_files_list\n\n elif file_type == 'prediction':\n if cmd_args.prediction_file:\n return PredictionFile(cmd_args.prediction_file)\n else:\n return None\n\n else:\n 'the user can insert here some code for suppeltementary files'","def cluster_files_reader(\n files_pattern, trainer_count, trainer_id, loader=pickle.load\n):\n\n def reader():\n if not callable(loader):\n raise TypeError(\"loader should be callable.\")\n file_list = glob.glob(files_pattern)\n file_list.sort()\n my_file_list = []\n for idx, fn in enumerate(file_list):\n if idx % trainer_count == trainer_id:\n print(\"append file: %s\" % fn)\n my_file_list.append(fn)\n for fn in my_file_list:\n with open(fn, \"r\") as f:\n lines = loader(f)\n for line in lines:\n yield line\n\n return reader","def parse_parameters(filename):\n\n # read in the parameters\n mainInput = ParserClass.Parser(filename)\n if 'LogFile' in mainInput['Inputs']:\n if mainInput['Inputs']['LogFileUsePID']:\n logger = Logging.Logger(mainInput['Inputs']['LogFile']+'_{}'.format(os.getpid()))\n else:\n logger = Logging.Logger(mainInput['Inputs']['LogFile'])\n \n else:\n logger = print\n\n # Generate a filelist to loop over\n filelist = np.loadtxt(mainInput['Inputs']['filelist'],dtype=str,ndmin=1)\n if isinstance(mainInput['Inputs']['data_dir'], type(None)):\n filelist = [filename for filename in filelist]\n else:\n filelist = ['{}/{}'.format(mainInput['Inputs']['data_dir'],\n filename.split('/')[-1]) for filename in filelist]\n \n # Some items should always be a list\n if not isinstance(mainInput['Inputs']['pipeline'], list):\n mainInput['Inputs']['pipeline'] = [mainInput['Inputs']['pipeline']]\n # Get the class names (modulename, classname)\n jobnames = [c for c in mainInput['Inputs']['pipeline']]\n\n logger('Running: '+' '.join(mainInput['Inputs']['pipeline']))\n\n\n prejobnames = [c for c in mainInput['Inputs']['preamble']]\n\n\n # Read the class parameter file\n classInput = ParserClass.Parser(mainInput['Inputs']['classParameters'])\n\n # Initalise the classes : classInput are the kwargs to initiate classes\n jobs = []\n for job in jobnames:\n jobs += [getClass(job)(logger=logger,**classInput[job])]\n\n # Initalise the classes : classInput are the kwargs to initiate classes\n prejobs = []\n for prejob in prejobnames:\n prejobs += [getClass(prejob)(logger=logger,**classInput[prejob])]\n\n\n return jobs,prejobs, filelist, mainInput, classInput, logger","def __init__(self, dataset_dir, listfile=None):\n Reader.__init__(self, dataset_dir, listfile)\n self._data = [line.split(',') for line in self._data]\n\n def process_ihm(x):\n return list(map(int, x.split(';')))\n\n def process_los(x):\n x = x.split(';')\n if x[0] == '':\n return ([], [])\n return (list(map(int, x[:len(x)//2])), list(map(float, x[len(x)//2:])))\n\n def process_ph(x):\n return list(map(int, x.split(';')))\n\n def process_decomp(x):\n x = x.split(';')\n if x[0] == '':\n return ([], [])\n return (list(map(int, x[:len(x)//2])), list(map(int, x[len(x)//2:])))\n\n self._data = [(fname, float(t), process_ihm(ihm), process_los(los),\n process_ph(pheno), process_decomp(decomp))\n for fname, t, ihm, los, pheno, decomp in self._data]","def read_files(filenames, gram_size=1):\n assert isinstance(filenames, list), \"filenames argument must be a list\"\n parser = MorParser()\n for fn in filenames:\n for uid, speaker, ngram in generate_chunks(parser.parse(fn), gram_size):\n yield fn, uid, speaker, ngram","def construct_bibfile_data(*paths):\n bibs = [reffile_factory(path) for path in paths]\n return bibs","def parseInputFileList (self) :\n filelist = []\n try :\n with open (self.cfgName) as fIn:\n for line in fIn:\n line = (line.split(\"#\")[0]).strip()\n if line:\n self.lines.append(line)\n except IOError:\n print \"*** WARNING: cfg file \" , self.cfgName , \" not found\"\n return\n\n #return filelist","def make_input_list(self):\n input_entries = [i for i in self.params.input if i != None]\n input_list = []\n\n # run through the list of multiple input entries (or just the one) and\n # concatenate the input list (right now GUI only supplies folder, but\n # this will change in future)\n for input_entry in input_entries:\n if os.path.isfile(input_entry):\n if input_entry.endswith('.lst'): # read from file list\n with open(input_entry, 'r') as listfile:\n listfile_contents = listfile.read()\n input_list.extend(listfile_contents.splitlines())\n elif input_entry.endswith(('pickle', 'mccd', 'cbf', 'img')):\n input_list.append(input_entry) # read in image directly\n\n elif os.path.isdir(input_entry):\n abs_inp_path = os.path.abspath(input_entry)\n for root, dirs, files in os.walk(abs_inp_path):\n for filename in files:\n found_file = os.path.join(root, filename)\n if found_file.endswith(('pickle', 'mccd', 'cbf', 'img')):\n input_list.append(found_file)\n\n # Pick a randomized subset of images\n if self.params.advanced.random_sample.flag_on and \\\n self.params.advanced.random_sample.number < len(input_list):\n inp_list = self.select_random_subset(input_list)\n else:\n inp_list = input_list\n\n return inp_list","def read_file(self, file_name_list):\n\n # Iterating over the file name list\n for file_name in file_name_list:\n\n # Opening MTF file\n #try: \n mtf_file = open(file_name,\"r\")\n #except Exception: pass # TODO\n\n # Reading file\n for line in mtf_file:\n # Processing line\n line_list = line.strip().split(\"\\t\")\n tf_id=line_list[0]\n name=line_list[1]\n database=line_list[2]\n tf_class=int(line_list[3])\n genes=line_list[4].split(\";\")\n genes_suffix=line_list[5].split(\";\")\n\n self.add(Motif(tf_id, name, database, tf_class, genes, genes_suffix))\n\n\n # Termination\n mtf_file.close()","def read_dir():\n file_list=[]\n title_list = []\n for filename in os.listdir(\"alignments/\"):\n if filename.endswith(\".aln\"): #Retrieve only alignment files.\n file_list.append(filename)\n with open (\"genID.txt\",'r') as x: #The genID.txt file contains relevant gene names.\n while True:\n rule = x.readline()\n if len(rule) > 0: #If the rule is empty, the program does not use it.\n if rule[0] == \"B\": #Only fetch gen names.\n title_list.append(rule) #The title_list is used to create the variant files in a later stadium\n else:\n break\n return file_list,title_list","def read(self, filenames, encoding=None):\n if isinstance(filenames, str):\n filenames = [filenames]\n read_ok = []\n for filename in filenames:\n try:\n with open(filename, encoding=encoding) as f:\n self.read_file(f)\n except OSError:\n continue\n read_ok.append(filename)\n return read_ok","def load(cls, filenames, config_factory=Config):\n return cls([config_factory(f, label=label) for label, f in filenames])","def create_read_list(samfile):\n read_sampler = ReadSampler()\n for line in samfile:\n line = sam_utils.SamAlignment(line)\n vals = line.get_aligned_blocks()\n if len(vals) > 1:\n logging.info(\"Skipping gapped read %s %s\"%(line.QNAME, str(vals))) \n read_sampler.add_read(vals[0])\n return read_sampler","def __init__(self, _format, name=\"Main_list.txt\"):\n self.format = _format\n self.name = name\n self.path = self.format + os.sep + self.name\n self.list = []\n self.length = 0","def files_to_reduce(parameters, evaluate_files):\n files_to_reduce = []\n sample = []\n shear = []\n\n if len(evaluate_files) == 0:\n files_to_reduce.extend(parameters)\n else:\n # call function for retrieve the IDs list\n evaluate_files_l = evaluate_files_list(evaluate_files)\n for parameter in parameters:\n if int(parameter['index']) in evaluate_files_l:\n files_to_reduce.append(parameter['filename'])\n sample.append(parameter['sample'])\n shear.append(parameter['shear'])\n\n return files_to_reduce, sample, shear","def _read_files(self) -> MMD:\n\t\theaders = []\n\t\tbodies = []\n\t\tif self.config.file_type == FileType.CSV:\n\t\t\tif self.config.source_uris.endswith('.zip'):\n\t\t\t\twith ZipFile(self.config.source_uris) as zf:\n\t\t\t\t\tfor item in zf.namelist():\n\t\t\t\t\t\tif item.endswith('.csv'):\n\t\t\t\t\t\t\t# with zf.open(item, 'r') as infile:\n\t\t\t\t\t\t\tcsv_reader = csv.reader(TextIOWrapper(zf.open(item, 'r'), 'utf-8'))\n\t\t\t\t\t\t\theaders.append(next(csv_reader))\n\t\t\t\t\t\t\t# need to find a more efficient way, the csv reader is a generator that can only be used once\n\t\t\t\t\t\t\tbodies.append(list(csv_reader))\n\t\t\telif self.config.source_uris.endswith('.csv'):\n\t\t\t\tfor uri in self.config.source_uris:\n\t\t\t\t\tif uri.endswith('.csv'):\n\t\t\t\t\t\tcsv_reader = csv.reader(open(uri, newline='', encoding='utf-8'))\n\t\t\t\t\t\theaders.append(next(csv_reader))\n\t\t\t\t\t\tbodies.append(list(csv_reader))\n\t\telif self.config.file_type == FileType.CNSCHEMA:\n\t\t\theader = ['@id', 'label_@language', 'label_@value']\n\t\t\tbody = []\n\t\t\twith open(self.config.source_uris, 'r') as load_f:\n\t\t\t\tload_dict = json.load(load_f)\n\t\t\t\theader.extend(load_dict['@context'].keys())\n\t\t\t\theader = [h for h in header if h not in ['label', 'range', 'domain', 'subClassOf']]\n\t\t\t\ttmp_h = [h for h in header if h not in ['@id', '@language', '@value']]\n\t\t\t\tfor item in load_dict['@graph']:\n\t\t\t\t\tif item['@id'].split('/')[-2] == 'resource':\n\t\t\t\t\t\trow = [item['@id'], item['label']['@language'], item['label']['@value']]\n\t\t\t\t\t\tfor h in tmp_h:\n\t\t\t\t\t\t\tif h in item:\n\t\t\t\t\t\t\t\trow.append(item[h])\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\trow.append(None)\n\t\t\t\t\t\tbody.append(tuple(row))\n\t\t\theaders.append(tuple(header))\n\t\t\tbodies.append(body)\n\t\telif self.config.file_type == FileType.OPENBASE:\n\t\t\theader = []\n\t\t\tbody = []\n\t\t\twith open(self.config.source_uris, 'r') as load_f:\n\t\t\t\tfor line in load_f:\n\t\t\t\t\trow = []\n\t\t\t\t\tflat_line = flatten_json(json.loads(line))\n\t\t\t\t\tfor key in flat_line:\n\t\t\t\t\t\tif key not in header:\n\t\t\t\t\t\t\theader.append(key)\n\t\t\t\t\tfor h in header:\n\t\t\t\t\t\tif h in flat_line:\n\t\t\t\t\t\t\trow.append(flat_line[h])\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\trow.append(None)\n\t\t\t\t\tbody.append(row)\n\t\t\tfor item in body:\n\t\t\t\tif len(item) < len(header):\n\t\t\t\t\titem.extend([None for i in range(len(header) - len(item))])\n\t\t\theaders.append(tuple(header))\n\t\t\tbodies.append(tuple([tuple(item) for item in body]))\n\t\telif self.config.file_type == FileType.OPENKS:\n\t\t\t# knowledge graph dataset loading \n\t\t\tif os.path.exists(self.config.source_uris + '/entities') and os.path.exists(self.config.source_uris + '/triples'):\n\t\t\t\theaders = [['entities'], ['triples']]\n\t\t\t\tfor file in ['entities', 'triples']:\n\t\t\t\t\ttmp = []\n\t\t\t\t\twith open(self.config.source_uris + '/' + file, 'r') as load_f:\n\t\t\t\t\t\tfor line in load_f:\n\t\t\t\t\t\t\ttmp.append(tuple([item.strip() for item in line.split('\\t')]))\n\t\t\t\t\t\tbodies.append(tuple(tmp))\n\t\t\t# general text dataset loading\n\t\t\telif os.path.exists(self.config.source_uris + '/train') and os.path.exists(self.config.source_uris + '/valid'):\n\t\t\t\theaders = [['train'], ['valid']]\n\t\t\t\tfor file in ['train', 'valid']:\n\t\t\t\t\ttmp = []\n\t\t\t\t\twith open(self.config.source_uris + '/' + file, 'r') as load_f:\n\t\t\t\t\t\tfor line in load_f:\n\t\t\t\t\t\t\ttmp.append(tuple([item.strip() for item in line.split('@@')]))\n\t\t\t\t\t\tbodies.append(tuple(tmp))\n\t\t\telse:\n\t\t\t\tlogger.warn('Only allows loading with entities and triples for now!')\n\t\t\t\traise IOError\n\t\telif self.config.file_type == FileType.NERO:\n\t\t\theaders = [['unlabeled_data'], ['predict'], ['pattern']]\n\t\t\tfor file in ['unlabeled_data', 'predict', 'pattern']:\n\t\t\t\ttmp = []\n\t\t\t\twith open(self.config.source_uris + '/' + file + '.json', 'r') as load_f:\n\t\t\t\t\tfor line in load_f:\n\t\t\t\t\t\ttmp.append(line.strip())\n\t\t\t\t\tbodies.append(tuple(tmp))\n\n\t\tmmd.name = self.config.data_name\n\t\tmmd.headers = headers\n\t\tmmd.bodies = bodies\n\t\treturn mmd","def read_input_files(self):\r\n\r\n for input_file in self.list_of_input_files:\r\n input_file.read_header_of_file()\r\n self.list_of_header_objects.extend(input_file.list_of_header_objects)\r\n self.list_of_header_objects_without_ID.extend(input_file.list_of_header_objects_without_ID)\r\n self.list_of_contigs.extend(input_file.list_of_contigs)\r\n\r\n self.list_of_header_objects = list(toolz.unique(self.list_of_header_objects, key=lambda x: x.tag_and_ID))\r\n self.list_of_header_objects_without_ID = list(\r\n toolz.unique(self.list_of_header_objects_without_ID, key=lambda x: x.line))\r\n self.list_of_contigs = list(toolz.unique(self.list_of_contigs, key=lambda x: x.line))\r\n self.list_of_header_objects.extend(self.list_of_header_objects_without_ID)\r\n self.list_of_header_objects.sort(key=lambda x: x.line)\r\n self.list_of_header_objects.extend(self.list_of_contigs)\r\n self.list_of_header_objects.sort(key=lambda x: x.tag, reverse=False)\r\n self.create_body_header_line_for_output()\r\n self.write_header_in_output_file()\r\n\r\n list_of_chrom = list(self.indices.keys())\r\n list_of_chrom.sort(key=lambda x: self.alphanum_key(x))\r\n for chrom in list_of_chrom:\r\n self.list_of_body_objects.clear()\r\n for input_file in self.list_of_input_files:\r\n input_file.read_specific_chrom_body_of_file(chrom)\r\n self.list_of_body_objects.extend(input_file.list_of_body_objects)\r\n\r\n self.adjust_body_records_to_samples()\r\n self.list_of_body_objects = list(toolz.unique(self.list_of_body_objects, key=lambda x: x.line))\r\n self.list_of_body_objects.sort(key=lambda x: self.alphanum_key(x.line))\r\n self.verify_and_merge_body_records()\r\n self.write_specific_chrom_in_output_file()","def initialize_files(file_name, ran, file_extension):\r\n \"\"\"Specifiy the exact file name and the number of files --> file_name_(range) e.g file_name=chickens ,ran=16\"\"\"\r\n answer_file_rep = [file_name + str(number) for number in range(1, ran)]\r\n answer_files = [file + \"{}\".format(file_extension) for file in answer_file_rep]\r\n answers = [\"answer\" + str(number) for number in range(1, ran)]\r\n return answer_files, ran, answers","def from_filenames(\n filenames,\n verbose=False,\n unhandled=None,\n compare_beam=None,\n compare_detector=None,\n compare_goniometer=None,\n scan_tolerance=None,\n format_kwargs=None,\n load_models=True,\n ):\n experiments = ExperimentList()\n for db in DataBlockFactory.from_filenames(\n filenames,\n verbose=verbose,\n unhandled=unhandled,\n compare_beam=compare_beam,\n compare_detector=compare_detector,\n compare_goniometer=compare_goniometer,\n scan_tolerance=scan_tolerance,\n format_kwargs=format_kwargs,\n ):\n experiments.extend(\n ExperimentListFactory.from_datablock_and_crystal(db, None, load_models)\n )\n return experiments","def loadFromFile(self, filename):\n\t\treturn []","def _open_files(inputs, mode):\n assert isinstance(inputs, list)\n\n local_open = pf.open\n return [local_open(ffile, mode=mode) for ffile in inputs]","def read_in_LC_files(input_files, obj_names, style='SNANA'):\n LC_list = []\n if style == 'SNANA':\n for i, input_file in enumerate(input_files):\n t, f, filts, err = np.genfromtxt(input_file,\n usecols=(1, 4, 2, 5), skip_header=18,\n skip_footer=1, unpack=True, dtype=str)\n t = np.asarray(t, dtype=float)\n f = np.asarray(f, dtype=float)\n err = np.asarray(err, dtype=float)\n\n sn_name = obj_names[i]\n new_LC = LightCurve(sn_name, t, f, err, filts)\n LC_list.append(new_LC)\n else:\n raise ValueError('Sorry, you need to specify a data style.')\n return LC_list","def buildfilelist():\r\n for files in filelist:\r\n if os.path.splitext(files)[1]=='.dxf': #查找目录下的dxf文件，加入到readfilelist文件列表中 \r\n readfilelist.append(files)\r\n #feilin=file('feilin(ph).dxf','w') #新建一个文件，名字先占位用，后续改成由配置文件中读入名称。 \r","def parse_files(files):\n ans = []\n if files:\n for f in files:\n split = f.split(\"=\")\n if len(split) != 2:\n raise Exception(\"invalid file specification '%s'\" % f)\n ans.append((split[0], split[1]))\n return ans","def read(self, filenames):\n if isinstance(filenames, basestring):\n filenames = [filenames]\n read_ok = []\n for filename in filenames:\n try:\n fp = open(filename)\n except IOError:\n continue\n self._read(fp, filename)\n fp.close()\n read_ok.append(filename)\n return read_ok","def Make_FileList(input_name):\n\tif args.input_type == 'FILE':\n\t\tFileList=[]\n\t\tFileList.append(input_name)\n\tif args.input_type == 'FOLDER':\n\t\tFileList = glob.glob('%s/*' % input_name)\n\treturn FileList","def __init__(self):\n self.filelist = list()","def files_list_reduce(filename, fieldnames):\n\n parameters = []\n with open(filename) as csv_file:\n\n reader = csv.DictReader(csv_file, fieldnames=fieldnames)\n iterRows = iter(reader)\n next(iterRows)\n for row in iterRows:\n if row['index'] == '':\n continue\n if row['index'] == 'END':\n break\n parameters.append(row)\n return parameters","def read(self,filenames):\n\n if isinstance(filenames, basestring):\n filenames = [filenames]\n read_ok = []\n for filename in filenames:\n try:\n fp = open(filename)\n except IOError:\n continue\n self._read(fp)\n fp.close()\n read_ok.append(filename)\n return read_ok","def get_data(methylation_files, names, window, smoothen=5):\n return [read_meth(f, n, window, smoothen) for f, n in zip(methylation_files, names)]","def read_data(r_filename, nr_filename, config):\n\t\n\t# Create a queue for each file\n\tr_queue = tf.train.string_input_producer(r_filename)\n\tnr_queue = tf.train.string_input_producer(nr_filename)\n\n\tr_result = _read_from_file(r_queue, config, class_label = 1)\n\tnr_result = _read_from_file(nr_queue, config, class_label = 0)\n\n\tmin_queue_examples = 100 # Currently an arbitrary number\n\n\tr_sequences, r_label_batch, r_subjects, r_names, r_coords, r_features = _generate_half_batch(\n\t\t\t\t\t\t\t\t\t\t\t\tr_result,\n\t\t\t\t\t\t\t\t\t\t\t\tmin_queue_examples,\n\t\t\t\t\t\t\t\t\t\t\t\tbatch_size = config.batch_size,\n\t\t\t\t\t\t\t\t\t\t\t\tnum_steps = config.num_steps,\n\t\t\t\t\t\t\t\t\t\t\t\ttest_mode = config.test_mode)\n\tnr_sequences, nr_label_batch, nr_subjects, nr_names, nr_coords, nr_features = _generate_half_batch(\n\t\t\t\t\t\t\t\t\t\t\t\tnr_result,\n\t\t\t\t\t\t\t\t\t\t\t\tmin_queue_examples,\n\t\t\t\t\t\t\t\t\t\t\t\tbatch_size = config.batch_size,\n\t\t\t\t\t\t\t\t\t\t\t\tnum_steps = config.num_steps,\n\t\t\t\t\t\t\t\t\t\t\t\ttest_mode = config.test_mode)\n\n\tsequence_batches_joined = tf.concat([r_sequences, nr_sequences], 0)\n\tlabel_batches_joined = tf.concat([r_label_batch, nr_label_batch], 0)\n\tsubjects_batches_joined = tf.concat([r_subjects, nr_subjects], 0)\n\tnames_batches_joined = tf.concat([r_names, nr_names], 0)\n\tcoords_batches_joined = tf.concat([r_coords, nr_coords], 0)\n\tfeature_batches_joined = tf.concat([r_features, nr_features], 0)\n\n\treturn sequence_batches_joined, label_batches_joined, subjects_batches_joined, names_batches_joined, coords_batches_joined, feature_batches_joined","def open_netcdf_files(rlzn_path_list,name_prefix): #{{{\n\n fopen_list = []\n for path in rlzn_path_list:\n netcdf_name = glob.glob(path+'/'+name_prefix)\n fopen_list.append(netCDF4.Dataset(netcdf_name[0],'r'))\n\n return fopen_list #}}}","def _generate_examples(self, files):\n idx = 0\n for filename in files:\n with open(filename) as file:\n for line in file:\n yield idx, {\"text\": line}\n idx += 1","def build_file_list(location, filters):\n f = []\n for (dir_path, dir_name, file_names) in os.walk(location):\n for file in file_names:\n f.append(os.path.join(dir_path, file))\n obj_list = map(lambda file: os.path.join(location, file), f)\n\n if type(filters) == list:\n for filter in filters:\n obj_list = [i for i in obj_list if filter in i]\n else:\n obj_list = [i for i in obj_list if filters in i]\n\n return obj_list","def prepare_list_of_files(kernel_name, kernel_file_list, params, grid, threads, block_size_names):\n temp_files = dict()\n\n kernel_string = get_kernel_string(kernel_file_list[0], params)\n name, kernel_string = prepare_kernel_string(kernel_name, kernel_string, params, grid, threads, block_size_names)\n\n if len(kernel_file_list) > 1:\n for f in kernel_file_list[1:]:\n #generate temp filename with the same extension\n temp_file = get_temp_filename(suffix=\".\" + f.split(\".\")[-1])\n temp_files[f] = temp_file\n #add preprocessor statements to the additional file\n _, temp_file_string = prepare_kernel_string(kernel_name, get_kernel_string(f, params), params, grid, threads, block_size_names)\n write_file(temp_file, temp_file_string)\n #replace occurences of the additional file's name in the first kernel_string with the name of the temp file\n kernel_string = kernel_string.replace(f, temp_file)\n\n return name, kernel_string, temp_files","def generate_read_list(num_files, world_size):\n return np.array_split(np.arange(num_files), world_size)","def prepare_reader(self, unused_filename_queue):\n raise NotImplementedError()","def get_file_list(mixer_file, select_random, use_list_of_files):\n logger = logging.getLogger(get_file_list.__name__)\n files = list()\n\n if use_list_of_files:\n with open(mixer_file, 'r') as list_file:\n for line in list_file:\n files.append(os.path.join('data/raw',line.strip()))\n\n if select_random:\n random.shuffle(files)\n\n else:\n\n mixer = parse_mixer_file(mixer_file)\n\n for m in mixer:\n path = os.path.join(project_dir, m[0])\n all_mixer_files = [os.path.join(path,f) for f in os.listdir(path) \n if os.path.isfile(os.path.join(path, f)) and f.split('.')[-1] == 'csv']\n\n current_files = list()\n # Check if the number of samples is limited\n if m[2] >= 0:\n sample_count = 0\n for f in all_mixer_files:\n # Get number of lines without the header line\n num_lines = sum(1 for line in open(f)) - 1\n\n if (sample_count + num_lines) > m[2]:\n current_files.append((f, m[2] - sample_count))\n sample_count += (m[2] - sample_count)\n break\n else:\n current_files.append((f, -1))\n sample_count += num_lines\n\n if sample_count < m[2]:\n logger.warn('Not enough samples ({} < {}): {}'.format(sample_count, m[2], m[0]))\n else:\n # No limit, take all samples in the files\n current_files = zip(all_mixer_files, [-1]*len(all_mixer_files))\n\n if m[1] < 0:\n # -1 means all .csv files\n files += current_files\n elif m[1] > 0:\n if m[1] > len(current_files):\n logger.warn('Not enough files ({} < {}): {}'.format(len(current_files),\n m[1], m[0]))\n files += current_files[:m[1]]\n\n if select_random:\n random.shuffle(files)\n else:\n files = sorted(files, key=lambda x: int(os.path.basename(x[0]).split('_')[-1].split('.')[0]))\n\n return files","def _create_filelist(self):\n print \"[--init] creating %s\" % self.file_list\n if self.source_file is not None:\n shutil.copyfile(self.source_file, self.file_list)\n elif self.source_path is not None:\n filenames = get_file_paths(self.source_path)\n if self.shuffle_file:\n random.shuffle(filenames)\n with open(self.file_list, 'w') as fh:\n for fname in filenames:\n fh.write(\"0000\\t\" + fname + \"\\n\")\n else:\n sys.exit(\"[--init] ERROR: \" +\n \"need to define input with --filelist or \" +\n \"--source-directory option, aborting\")\n read_only(self.file_list)","def __init__(self, names, file_extensions, version):\n assert isinstance(names, collections.abc.Sequence), type(names)\n assert names\n assert isinstance(file_extensions, collections.abc.Sequence), type(file_extensions)\n assert file_extensions\n if __debug__:\n for name in names:\n assert isinstance(name, str), type(name)\n assert name\n for file_extension in file_extensions:\n assert isinstance(file_extension, str), type(file_extension)\n assert file_extension\n assert file_extension.startswith('.'), file_extension\n assert isinstance(version, tuple) or version is None\n self.names = [name for name in names]\n self.default_name = self.names[0]\n self.file_extensions = [file_extension.lower() for file_extension in file_extensions]\n self.default_file_extension = self.file_extensions[0]\n self.version = version","def parse_from_list(l, os_name=None):\n\n if os_name in ['windows', 'nt']:\n FilePathObject = WindowsFilePath\n elif os_name in ['posix', 'linux']:\n FilePathObject = PosixFilePath\n else:\n raise ValueError('incorrect os_name given')\n\n if not isinstance(l, (list, tuple)):\n raise ValueError('expect a list with filepaths')\n\n l_args = map(lambda x: tuple(x) if isinstance(\n x, (tuple, list)) else tuple([x]), l)\n\n return [FilePathObject(*fp) for fp in l_args]","def read_parse_file(params):\n\tparam_names = []\n\tparam_options = []\n\tif not os.path.isfile(params.parse_file):\n\t\tprint(\"parse file does not exist! ({})\".format(params.parse_file))\n\t\tsys.exit(NO_PARSE)\n\twith open(params.parse_file, 'r') as pf:\n\t\t# first line should be iteration regex\n\t\tsetattr(params, 'iteration_regex', re.compile(pf.readline().strip()))\n\t\tfor line in pf:\n\t\t\tparam_desc = line.split(';')\n\t\t\tparam_names.append(param_desc[0])\n\t\t\tparam_options.append(param_desc[1])\n\n\treturn param_names,param_options","def readFiles(trainFile, testFile):\r\n\r\n\t# Open both files and split into lines\r\n\twith open(trainFile) as f:\r\n\t\ttrainLines = f.read().splitlines()\r\n\r\n\twith open(testFile) as f:\r\n\t\ttestLines = f.read().splitlines()\r\n\r\n\t\t\r\n\t# Extract training data\r\n\tfor line in trainLines:\r\n\t\tline = line.split()\r\n\t\t\r\n\t\tid = line[0]\r\n\t\tclass_id = line[1]\r\n\t\twords = line[2:]\r\n\t\t\r\n\t\trow = [id, class_id, words]\r\n\t\t\r\n\t\ttrainingData.append(row)\r\n\t\t\r\n\t\t\r\n\t# Extract testing data\r\n\tfor line in testLines:\r\n\t\tline = line.split()\r\n\t\t\r\n\t\tid = line[0]\r\n\t\tclass_id = line[1]\r\n\t\twords = line[2:]\r\n\t\t\r\n\t\trow = [id, class_id, words]\r\n\t\t\r\n\t\ttestData.append(row)","def generate_reader(n):\n counter = 1\n for i in range(n):\n name = generate_reader_name()\n if not name in readers:\n readers[name] = f'Reader/{counter}'\n counter += 1","def _read_dataset(a_files):\n return [(list(ifields[TXT_IDX]), ifields[GLD_IDX])\n for ifile in a_files for ifields in iterlines(ifile)]","def __init__(self, dataset_dir, listfile=None, period_length=48.0):\n Reader.__init__(self, dataset_dir, listfile)\n self._data = [line.split(\",\") for line in self._data]\n self._data = [(x, int(y)) for (x, y) in self._data]\n self._period_length = period_length","def construct_combined_set(filenames, sensor_names, cnt_preprocessors,\n marker_def, end_marker_def, trial_classes,\n trial_start_offset_ms, trial_stop_offset_ms,\n min_break_length_ms, max_break_length_ms,\n break_start_offset_ms, break_stop_offset_ms,\n last_set_split_trial, add_trial_breaks=True,\n filename_to_extra_args=None):\n default_args = deepcopy(locals())\n sets = []\n\n if filename_to_extra_args is not None:\n for filename_with_args in filename_to_extra_args:\n assert filename_with_args in filenames\n\n for i_file, filename in enumerate(filenames):\n this_args = copy(default_args)\n if filename_to_extra_args is not None and (\n filename in filename_to_extra_args):\n for key in filename_to_extra_args[filename]:\n assert key in this_args\n this_args[key] = filename_to_extra_args[filename][key]\n assert key != 'last_set_split_trial', \"Does not make sense :)\"\n marker_segmenter = MarkerSegmenter(segment_ival=[\n this_args['trial_start_offset_ms'], \n this_args['trial_stop_offset_ms']],\n marker_def=this_args['marker_def'],\n trial_classes=this_args['trial_classes'],\n end_marker_def=this_args['end_marker_def'])\n trial_break_adder = AddTrialBreaks(min_length_ms=this_args['min_break_length_ms'],\n max_length_ms=this_args['max_break_length_ms'], \n start_offset_ms=this_args['break_start_offset_ms'], \n stop_offset_ms=this_args['break_stop_offset_ms'],\n start_marker_def=this_args['marker_def'],\n end_marker_def=this_args['end_marker_def'])\n if (i_file < len(filenames) - 1) or (\n this_args['last_set_split_trial'] is None):\n segmenters = [marker_segmenter,]\n else:\n segmenters = [marker_segmenter,\n RestrictTrialRange(0,this_args['last_set_split_trial'])]\n if this_args['add_trial_breaks']:\n segmenters.append(trial_break_adder)\n segmenter = PipelineSegmenter(segmenters)\n cnt_set = SetWithMarkers(BBCIDataset(filename,\n load_sensor_names=this_args['sensor_names']),\n this_args['cnt_preprocessors'],\n segmenter) \n sets.append(cnt_set)\n\n # add last set last part as test set if you split apart last set\n # we use that this_args is now from last set already\n if last_set_split_trial is not None:\n segmenters = [marker_segmenter,\n RestrictTrialRange(last_set_split_trial,None),]\n if this_args['add_trial_breaks']:\n segmenters.append(trial_break_adder)\n segmenter = PipelineSegmenter(segmenters)\n cnt_set = SetWithMarkers(BBCIDataset(filenames[-1], # again last file needed\n load_sensor_names=this_args['sensor_names']),\n this_args['cnt_preprocessors'],\n segmenter)\n sets.append(cnt_set)\n dataset = CombinedSet(sets)\n return dataset","def buildRegFilterList(self, filename, listname='regFilterList'):","def read_list_file(path_file):\n with open(path_file,'r') as f_in:\n lines = f_in.readlines()\n lines = [x for x in lines if not (x.strip() == '' or x.strip()[0] == '#')]\n left_file_list = []\n right_file_list = []\n gt_file_list = []\n conf_file_list = []\n for l in lines:\n to_load = re.split(',|;',l.strip())\n left_file_list.append(to_load[0])\n right_file_list.append(to_load[1])\n if len(to_load)>2:\n gt_file_list.append(to_load[2])\n if len(to_load)>3:\n conf_file_list.append(to_load[3])\n return left_file_list,right_file_list,gt_file_list,conf_file_list","def from_file_list(\n cls,\n audio_file_list,\n target_sr=None,\n int_values=False,\n offset=0,\n duration=0,\n trim=False,\n channel_selector=None,\n *args,\n **kwargs,\n ):\n if isinstance(channel_selector, int):\n # Shortcut when selecting a single channel\n if channel_selector >= len(audio_file_list):\n raise RuntimeError(\n f'Channel cannot be selected: channel_selector={channel_selector}, num_audio_files={len(audio_file_list)}'\n )\n # Select only a single file\n audio_file_list = [audio_file_list[channel_selector]]\n # Reset the channel selector since we applied it here\n channel_selector = None\n\n samples = None\n\n for a_file in audio_file_list:\n # Load audio from the current file\n a_segment = cls.from_file(\n a_file,\n target_sr=target_sr,\n int_values=int_values,\n offset=offset,\n duration=duration,\n channel_selector=None,\n trim=False, # Do not apply trim to individual files, it will be applied to the concatenated signal\n *args,\n **kwargs,\n )\n\n # Only single-channel individual files are supported for now\n if a_segment.num_channels != 1:\n raise RuntimeError(\n f'Expecting a single-channel audio signal, but loaded {a_segment.num_channels} channels from file {a_file}'\n )\n\n if target_sr is None:\n # All files need to be loaded with the same sample rate\n target_sr = a_segment.sample_rate\n\n # Concatenate samples\n a_samples = a_segment.samples[:, None]\n\n if samples is None:\n samples = a_samples\n else:\n # Check the dimensions match\n if len(a_samples) != len(samples):\n raise RuntimeError(\n f'Loaded samples need to have identical length: {a_samples.shape} != {samples.shape}'\n )\n\n # Concatenate along channel dimension\n samples = np.concatenate([samples, a_samples], axis=1)\n\n # Final setup for class initialization\n samples = np.squeeze(samples)\n sample_rate = target_sr\n\n return cls(\n samples, sample_rate, target_sr=target_sr, trim=trim, channel_selector=channel_selector, *args, **kwargs,\n )","def __init__(self, dataset_dir, listfile=None, period_length=48.0):\n Reader.__init__(self, dataset_dir, listfile)\n self._data = [line.split(',') for line in self._data]\n self._data = [(x, int(y)) for (x, y) in self._data]\n self._period_length = period_length","def __init__(self, filename, listfile=True):\n if hasattr(filename, 'read'):\n self.file = filename\n else:\n self.file = open(filename, 'rb')\n self.header = self.read_header()\n self.hash_table = self.read_table('hash')\n self.block_table = self.read_table('block')\n if listfile:\n self.files = self.read_file('(listfile)').splitlines()\n else:\n self.files = None","def __init__(self, dataset_dir, listfile=None):\n Reader.__init__(self, dataset_dir, listfile)\n self._data = [line.split(',') for line in self._data]\n self._data = [(mas[0], float(mas[1]), list(map(int, mas[2:]))) for mas in self._data]","def __init__(self,file_reader):\n self.file_reader = file_reader","def mk_parses(listfile, corenlp_host):\n # if not listfile.endswith('.listfile'):\n # filetype = 'Co-Reference List file'\n # error = 'has incorrect file type'\n # raise FilenameException(\"Error: %s %s\" % (filetype, error))\n\n try:\n with open(listfile) as f:\n pserver = jsonrpc.ServerProxy(jsonrpc.JsonRpc20(),\n jsonrpc.TransportTcpIp(\n addr=(corenlp_host, 8080), limit=1000))\n parses = dict([(get_id(path), FileParse(path, pserver))\n for path in f.readlines()\n if path.lstrip()[0] != '#'])\n except IOError:\n stderr.write(strerror(EIO)) # stderr.write does not have newlines\n stderr.write(\"\\nERROR: Could not open list file\\n\")\n exit(EIO)\n else:\n return parses","def fileReader(self, fileHouses, fileBatteries):\n\n # Initiate ID\n ID = 0\n\n # Open the file containing houses\n with open(fileHouses) as h, open(fileBatteries) as b:\n\n # Read the file and separate values in list\n readerHouses = csv.reader(h, delimiter=',', quoting=csv.QUOTE_NONE)\n readerBatteries = csv.reader(b, delimiter=',',\n quoting=csv.QUOTE_NONE)\n\n # Skip the header of the file\n next(h)\n next(b)\n\n # Create instances of houses or batteries\n for row in readerHouses:\n self.houses.append(houseClass.house(ID, int(row[0]),\n int(row[1]),\n float(row[2])))\n ID += 1\n\n ID = 0\n\n for row in readerBatteries:\n self.batteries.append(batteryClass.battery(ID, int(row[0]),\n int(row[1]), float(row[2])))\n ID += 1","def list(ffiles):\n ret = {}\n print('Reading: ')\n for ffile in ffiles:\n print(ffile)\n ret[ffile] = data_file(ffile)\n return ret","def from_files(paths: list[str]) -> Catalog:\n cat = Catalog()\n for file in paths:\n with fsspec.open(file, mode=\"r\") as fh:\n new_cat = Catalog.from_str(fh.read())\n cat = cat.join(new_cat)\n return cat","def _open_files(path, filenames, barcode, queue):\n if not exists(path):\n mkdir(path)\n\n handles = []\n\n for filename in filenames:\n base, ext = basename(filename).split('.', True)\n handles.append(\n Handle('{}/{}_{}.{}'.format(path, base, barcode, ext), queue,\n f_open=_type_handler[ext.split('.')[-1]]))\n\n return handles","def read_files(self):\n for f in self.filenames:\n self.games.extend(pgn.loads(open(f).read()))","def build_data_from_file(cls,file_path,number_elems=None):\n raise NotImplementedError('Abstract method has not been implemented')","def load_files(basis_handles, parameter_handles):\n\n logging.info('Loading basis matrices')\n\n bases = [load_basis(handle) for handle in basis_handles]\n\n logging.info('Loading scaling parameters')\n\n parameters = [load_parameters(handle) for handle in parameter_handles]\n\n return bases, parameters","def load_training_data(list_files):\n training_data = []\n for tr_file in list_files:\n with open(os.path.join(\"data\", tr_file)) as csv_file:\n reader = csv.reader(csv_file, delimiter=\",\")\n next(reader)\n for row in reader:\n training_data.append(row[1])\n return training_data","def read_files(self):\n files = []\n # if this is test folder then there are no labels\n if 'test' in self.list_path:\n for item in self.img_list:\n image_path = item\n name = os.path.splitext(os.path.basename(image_path[0]))[0]\n files.append({\n \"img\": image_path[0],\n \"name\": name,\n })\n else:\n for item in self.img_list:\n image_path, label_path = item\n name = os.path.splitext(os.path.basename(label_path))[0]\n files.append({\n \"img\": image_path,\n \"label\": label_path,\n \"name\": name,\n \"weight\": 1\n })\n return files","def parseInputFileList (self):\n filelist = []\n try:\n with open (self.cfgName) as fIn:\n for line in fIn:\n line = (line.split(\"@@@\")[0]).strip()\n if line:\n self.lines.append(line)\n except IOError:\n print \"*** WARNING: label cfg file \" , self.cfgName , \" not found\"\n return","def Load_trials(files=[], trials=[]):\n\n # adds each file to files list\n\n while True:\n new_file = Add_file(files)\n if new_file:\n files.append(new_file)\n else:\n break\n\n for file in files:\n try:\n ff = open(file)\n failed_to_read_counter = 0\n ff.readline() # skips the title line\n line_read_counter = 0\n while True:\n line_read_counter += 1\n try:\n line = ff.readline()\n except:\n failed_to_read_counter += 1\n continue\n # breaks at last line\n if not line:\n break\n else:\n # splits by tabs\n try:\n fields = line.split(\"\\t\")\n rank = int(fields[0])\n except:\n continue\n # instances a new trial for each line and includes in list of trials\n trial = (\n Trial.add_trial(rank, fields[1], fields[2], fields[3], fields[4], fields[5], fields[6], fields[7],\n file))\n ff.close()\n finally:\n a=0\n return trials","def load_from_files(*filenames,**kwargs):\n if 'keys' in kwargs.keys() and 'dtype' not in kwargs.keys():\n raise ValueError('Please set dtype as well.')\n elif 'keys' in kwargs.keys() and 'dtype' in kwargs.keys():\n if len(kwargs['keys']) != len(kwargs['dtype']):\n raise ValueError('Length of keys and dtype must match.')\n\n z_range = kwargs.pop('z_range',None)\n z_key = kwargs.pop('z_key',None)\n keys = kwargs.pop('keys',['Name','RA','Dec','z'])\n dtypes = kwargs.pop('dtype',[object,float,float,float])\n case_sensitive = kwargs.pop('case_sensitive',False)\n comments = kwargs.pop('comments','#')\n delimiter = kwargs.pop('delimeter',None)\n return_fileindex = kwargs.pop('return_fileindex',False)\n\n if kwargs != {}:\n unknown_kw = ' '.join(kwargs.keys())\n raise TypeError('load_from_files got unknown keyword arguments: {}'.format(unknown_kw))\n\n if not case_sensitive:\n keys = [a.upper() for a in keys]\n\n if z_range is not None and z_key is None:\n z_keys = [key for key in keys \n if key[0].upper() == 'Z' or key.upper() == \"REDSHIFT\"] \n if len(z_keys) == 0:\n raise ValueError('Failed to determine z_key, please set kwarg z_key')\n elif len(z_keys) > 1:\n raise ValueError('Ambiguous z_key, please set kwargs z_key manually')\n else:\n z_key = z_keys[0]\n\n out = None\n fileindex = []\n\n for k,filename in enumerate(filenames):\n tmp = np.genfromtxt(filename,names=True,comments=comments,dtype=None,\n case_sensitive=case_sensitive,delimiter=delimiter)\n \n if z_range is None:\n tmp2 = np.zeros((len(tmp),),dtype=zip(keys,dtypes))\n fileindex.extend([k for a in range(len(tmp))])\n for key in keys:\n tmp2[key] = tmp[key]\n else:\n z_filter = (tmp[z_key] >= z_range[0]) & (tmp[z_key] < z_range[1]) \n tmp2 = np.zeros((np.sum(z_filter),),dtype=zip(keys,dtypes))\n fileindex.extend([k for a in range(np.sum(z_filter))])\n for key in keys:\n tmp2[key] = tmp[key][z_filter]\n \n if out is None:\n out = tmp2\n else:\n out = np.concatenate((out,tmp2))\n \n if return_fileindex:\n return [out[key] for key in keys] + [np.array(fileindex)]\n else:\n return [out[key] for key in keys]","def get_movie_data(files: list) -> list:\n pass","def file_reader(filename = 'conv_params'):\n\n with open(filename) as f:\n info = f.readlines()\n info = [i.strip() for i in info] # each element in info is a string of a line from the file\n info = [i.split() for i in info] # split each whitespace delimited element into a list of lists\n info = [[i.split('-') for i in j] for j in info] # note info is 3 layers deep\n\n info[2] = info[2][0] # makes default E just a single string of the number\n info[3] = info[3][0]\n\n return info","def from_files(cls, mos_file_paths, *, allow_incomplete=False):\n logger.info(\"Making MosCollection from %s files\", len(mos_file_paths))\n mos_readers = sorted([\n mr\n for mr in [MosReader.from_file(mfp) for mfp in mos_file_paths]\n if mr is not None\n ])\n return cls(mos_readers, allow_incomplete=allow_incomplete)","def mkfilelist(filesN, filesE):\n newlist = []\n for _fN in filesN:\n for _fE in filesE:\n trN = SacIO(_fN, headonly=True)\n stN = trN.kstnm.rstrip()\n dtN = trN.delta\n trE = SacIO(_fE, headonly=True)\n stE = trE.kstnm.rstrip()\n dtE = trE.delta\n if stN == stE:\n if dtE != dtN:\n print \"sampling intervals are not identical for %s and %s\" % (_fN, _fE)\n break\n else:\n newlist.append((_fN, _fE))\n break\n\n return newlist, 1. / dtN","def read_model_list(self,filename):\n\n self.grid_params = config.grid_params\n\n # set the correct dimension:\n self.ndim = len(self.grid_params)\n\n # set prefix and postfix:\n listfile = open(filename,\"r\")\n line = listfile.readline().strip();\n columns = line.split()\n if (len(columns) < 1): sys.exit(\"Erroneous first line in %s.\"%(filename))\n self.prefix = columns[0]\n if (len(columns) > 1): self.postfix = columns[1]\n\n # read models and put them into evolutionary tracks:\n nmodels = 0\n nmodes = 0\n models_small_spectra = []\n for line in listfile:\n line = line.strip()\n columns = line.split()\n glb = np.empty((nglb,),dtype = gtype)\n glb[imass] = utilities.to_float(columns[1])\n glb[iradius] = utilities.to_float(columns[2])\n glb[iluminosity] = utilities.to_float(columns[3])\n glb[iz0] = utilities.to_float(columns[4])\n glb[ix0] = utilities.to_float(columns[5])\n glb[iage] = utilities.to_float(columns[6])\n glb[itemperature] = utilities.to_float(columns[7])\n\n i = 8\n for (name, name_latex) in config.user_params:\n glb[user_params_index[name]] = utilities.to_float(columns[i])\n i += 1\n\n # print glb[0]\n aModel = Model(glb, _name = columns[0])\n exceed_freqlim = aModel.read_file(self.prefix + columns[0] + self.postfix)\n aModel.multiply_modes(1.0/aModel.glb[ifreq_ref]) # make frequencies non-dimensional\n aModel.sort_modes()\n aModel.remove_duplicate_modes()\n for track in self.tracks:\n if (track.matches(aModel)):\n track.append(aModel)\n break\n else:\n aTrack = Track(aModel,self.grid_params)\n self.tracks.append(aTrack)\n nmodels += 1\n nmodes += len(aModel.modes)\n if (not exceed_freqlim):\n models_small_spectra.append(aModel.name)\n print(nmodels, nmodes)\n listfile.close()\n\n # right list of models with spectra which are too small in a file:\n output = open(\"models_small_spectra\",\"w\")\n for name in models_small_spectra: output.write(name+\"\\n\")\n output.close()\n\n # sort tracks:\n for track in self.tracks: track.sort()\n\n # sanity check:\n for track in self.tracks:\n duplicate = track.duplicate_ages()\n if duplicate[0]:\n print(\"ERROR: the track \",track.grid_params,\" = \",track.params)\n print(\" has models with the same age. Please remove\")\n print(\" duplicate models.\")\n print(\" Check models:\", duplicate[1], duplicate[2])\n sys.exit(1)\n\n # update list of indices:\n self.ndx = range(len(self.tracks))\n\n # need to create grid from scratch since tracks have been sorted.\n self.grid = np.asarray([track.params for track in self.tracks])","def from_args(args, verbose=False, unhandled=None):\n\n # Create a list for unhandled arguments\n if unhandled is None:\n unhandled = []\n\n experiments = ExperimentList()\n ## First try as image files\n # experiments = ExperimentListFactory.from_datablock(\n # DataBlockFactory.from_args(args, verbose, unhandled1))\n\n # Try to load from serialized formats\n for filename in args:\n try:\n experiments.extend(\n ExperimentListFactory.from_serialized_format(filename)\n )\n if verbose:\n print(\"Loaded experiments from %s\" % filename)\n except Exception as e:\n if verbose:\n print(\"Could not load experiments from %s: %s\" % (filename, str(e)))\n unhandled.append(filename)\n\n # Return the experiments\n return experiments","def infile_list(args):\n infiles = []\n for arg in args:\n infiles += glob.glob(arg)\n infiles = [pipes.quote(f) for f in infiles]\n return infiles","def readFromFiles(self, networkFile, demandFile):\n self.readNetworkFile(networkFile)\n self.readDemandFile(demandFile)\n self.validate()\n self.finalize()","def test_file_reader(self) -> None:\n result = [['123', 'Jin He', 'Computer Science'],\n ['234', 'Nanda Koka', 'Software Engineering'],\n ['345', 'Benji Cai', 'Software Engineering']]\n # file have header\n self.assertTrue(\n list(file_reader('C:/Users/Nidhi/Desktop/SEM3/810/HW08/student_majors.txt', 3, '|', True)) == result)\n # file without header\n self.assertFalse(\n list(file_reader('C:/Users/Nidhi/Desktop/SEM3/810/HW08/student_majors.txt', 3, '|')) == result)\n # More than 3 datafield\n with self.assertRaises(ValueError):\n list(file_reader(\n 'C:/Users/Nidhi/Desktop/SEM3/810/HW08/student_majors.txt', 4, '|', True))\n # file not found\n with self.assertRaises(FileNotFoundError):\n list(file_reader('abc.txt', 3, '|', True))","def loadInputFiles(self):\n\t\tfor filename in self.input_filename_list:\n\t\t\tfor module in self.modules:\n\t\t\t\tmodule.Add(filename)","def model_files(cmd_args):\n if cmd_args.learning_file_list:\n learning_files_list = files_constructor(cmd_args, file_type='learning')\n else:\n learning_files_list = None\n\n if cmd_args.prediction_file:\n prediction_file = files_constructor(cmd_args, file_type='prediction')\n else:\n prediction_file = None\n\n\n return learning_files_list, prediction_file","def load_runner(flist, **kwargs):\n if isinstance(flist, str):\n flist = [flist]\n frame_list = []\n for fname in flist:\n frame_list += _gen_frame_list(fname)\n return _frame_loader(frame_list, **kwargs)","def getFileList(*args, filespec: AnyStr=\"\", folder: AnyStr=\"\", **kwargs)->List[AnyStr]:\n pass","def read_file(inp_fn):\n lines = [line.strip().split(\",\")\n for line in open(inp_fn)\n if not (line.startswith(\"#\"))]\n return [(int(line[0]), year_record({\"male\": int(line[-3]),\n \"female\": int(line[-2]),\n \"unknown\": int(line[-1])},\n None, None))\n for line in lines[1:]]","def get_file_data(reader_file):\n\n complete_data_list = []\n for row in reader_file:\n complete_data_list.append(row)\n\n return complete_data_list","def select_files(input_line):\n uri = str(input_line.split(',')[0])\n label = str(input_line.split(',')[1])\n\n yield uri, label","def ReadFilesGenerator(self):\n\n for file in self._file_names:\n file_list = []\n\n # TODO see further into yielding one line at a time\n with open(file, 'r', encoding='mbcs') as sped:\n file_list = sped.read().splitlines()\n\n if not self.isSigned(file_list):\n file_list = self.stripSignature(file_list)\n\n yield file, file_list","def Open(self):\n fileHandler = open(self.path, \"r\")\n self.list = []\n constructor = None\n if self.format == \"music\": # Escoger el constructor adecuado\n constructor = Format.Music\n elif self.format == \"videos\":\n constructor = Format.Videos\n elif self.format == \"pictures\":\n constructor = Format.Pictures\n\n for line in fileHandler:\n name, author, album, year, _type, path = line.strip().split(\"¬\")\n entry = constructor(name, author, album, year, _type, path)\n self.list.append(entry)\n\n self.length = len(self.list)\n fileHandler.close()","def _generate_examples(self, **kwargs):\n file_paths = kwargs.get(\"file_paths\")\n if not file_paths:\n raise ValueError(\"Must pass file_paths.\")\n\n for file_path in file_paths:\n for record in SeqIO.parse(file_path, \"fasta\"):\n yield record.id, {\n \"sequence\": str(record.seq),\n \"description\": str(record.description),\n \"id\": str(record.id),\n }","def in_filepath_list(class_paths: List[str]) -> List:\n registry, not_founds = build_registry(class_paths)\n builder = FilepathListBuilder()\n source = builder.build(registry)\n\n return [source, not_founds]","def prepare_reader(self, filename_queue, batch_size=1024):\n reader = tf.TFRecordReader()\n _, serialized_examples = reader.read_up_to(filename_queue, batch_size)\n\n tf.add_to_collection(\"serialized_examples\", serialized_examples)\n return self.prepare_serialized_examples(serialized_examples)","def create_file_list(params):\n data_dir = params.get('data_dir', '')\n params['file_list'] = \".tmp.txt\"\n imgtype_list = {'jpg', 'bmp', 'png', 'jpeg', 'rgb', 'tif', 'tiff'}\n with open(params['file_list'], \"w\") as fout:\n tmp_file_list = os.listdir(data_dir)\n for file_name in tmp_file_list:\n file_path = os.path.join(data_dir, file_name)\n if imghdr.what(file_path) not in imgtype_list:\n continue\n fout.write(file_name + \" 0\" + \"\\n\")","def read_lists(path_to_lists, taille,taille_sup):\n\n os.chdir(path_to_lists)\n\n heme = [i.strip() for i in open(\"heme.list\").readlines()]\n heme_sample = data_sample(heme,taille_sup)\n\n steroid = [i.strip() for i in open(\"steroid.list\").readlines()]\n steroid_sample = data_sample(steroid,len(steroid))\n\n nucleotide = [i.strip() for i in open(\"nucleotide.list\").readlines()]\n nucleotide_sample = data_sample(nucleotide,taille)\n\n control = [i.strip() for i in open(\"control.list\").readlines()]\n control_sample = data_sample(control,taille)\n\n #data_total = heme_sample+nucleotide_sample+control_sample+steroid_sample\n\n data_total = heme_sample+nucleotide_sample+control_sample\n return data_total,heme,steroid,nucleotide,control","def __init__(self, dataset_dir, listfile=None):\n Reader.__init__(self, dataset_dir, listfile)\n self._data = [line.split(',') for line in self._data]\n self._data = [(x, float(t), int(y)) for (x, t, y) in self._data]","def set_files(self, file_list):\n\tif file_list==None: return []\n\timport types\n\tisString = isinstance(file_list, types.StringTypes) \n\tisList = isinstance(file_list, list) \n\tassert isString or isList, \"You should provide a list of files as list or as CVS string!\"\n\tif isList: return file_list\n\tif isString :\n\t import re\n\t file_list_converted = re.sub(r'\\s', '', file_list).split(',') #remove all whitespaces\n\t return file_list_converted","def defineFILEandRANK(files: int, ranks: int) -> Tuple[List[str]]:\r\n alpha = 'abcdefghijklmnopqrstuvwxyz'\r\n fileList = []\r\n rankList = []\r\n for file in range(files):\r\n fileList.append(alpha[file])\r\n for rank in reversed(range(0, ranks)):\r\n rankList.append(str(rank))\r\n \r\n return fileList, rankList"],"string":"[\n \"def initialize_file_readers():\\n savefile_path = os.path.join(os.getcwd()+ \\\"/../data/\\\", SAVE_FILE)\\n file_reader_list = []\\n for file in os.listdir(savefile_path):\\n file_reader = open(os.path.join(savefile_path,file), \\\"r\\\")\\n file_reader_list.append({\\\"file_reader\\\": file_reader, \\\"last_read\\\": { \\\"word\\\": \\\"\\\", \\\"doc_score_list\\\": []}})\\n return file_reader_list\",\n \"def get_file_list(params):\\n if params['mode'] == 'test':\\n create_file_list(params)\\n\\n with open(params['file_list']) as flist:\\n full_lines = [line.strip() for line in flist]\\n\\n full_lines = shuffle_lines(full_lines, params[\\\"shuffle_seed\\\"])\\n\\n # use only partial data for each trainer in distributed training\\n if params['mode'] == 'train':\\n real_trainer_num = max(trainers_num, 1)\\n img_per_trainer = len(full_lines) // real_trainer_num\\n full_lines = full_lines[trainer_id::real_trainer_num][:img_per_trainer]\\n\\n return full_lines\",\n \"def __init__(self, files):\\n self.files = files and [NamedFile(data=d, filename=fn) for (d, fn) in files]\",\n \"def _load_seqs(file_format, filename, fmt, kw, parser_kw):\\n fmt = fmt or file_format\\n if not fmt:\\n msg = \\\"could not determined file format, set using the format argument\\\"\\n raise ValueError(msg)\\n parser_kw = parser_kw or {}\\n for other_kw in (\\\"constructor_kw\\\", \\\"kw\\\"):\\n other_kw = kw.pop(other_kw, None) or {}\\n kw.update(other_kw)\\n return list(FromFilenameParser(filename, fmt, **parser_kw))\",\n \"def _read(self, file_paths: List[str], **read_opts) -> List[DataFrame]:\\n return [read_file(file_path, **read_opts) for file_path in file_paths]\",\n \"def MFileReader(fvcom, *args, **kwargs):\\n\\n if isinstance(fvcom, str):\\n FVCOM = FileReader(fvcom, *args, **kwargs)\\n else:\\n for file in fvcom:\\n if file == fvcom[0]:\\n FVCOM = FileReader(file, *args, **kwargs)\\n else:\\n FVCOM += FileReader(file, *args, **kwargs)\\n\\n return FVCOM\",\n \"def read_data_files(filenames, datapath, ids=None):\\n filenames = np.array(filenames) # make sure it's array\\n if ids is None:\\n ids = range(0, len(filenames))\\n\\n for i in [filenames[k] for k in ids]:\\n yield str(open(datapath+i, 'r').read())\",\n \"def files_constructor(cmd_args, file_type):\\n\\n if file_type == 'learning':\\n learning_files_list = [LearningFile(address, cmd_args.primary_selex_sequence) for address in cmd_args.learning_file_list]\\n [learning_files_list[i].cycle_matrix(i, len(learning_files_list)) for i in range(len(learning_files_list))]\\n return learning_files_list\\n\\n elif file_type == 'prediction':\\n if cmd_args.prediction_file:\\n return PredictionFile(cmd_args.prediction_file)\\n else:\\n return None\\n\\n else:\\n 'the user can insert here some code for suppeltementary files'\",\n \"def cluster_files_reader(\\n files_pattern, trainer_count, trainer_id, loader=pickle.load\\n):\\n\\n def reader():\\n if not callable(loader):\\n raise TypeError(\\\"loader should be callable.\\\")\\n file_list = glob.glob(files_pattern)\\n file_list.sort()\\n my_file_list = []\\n for idx, fn in enumerate(file_list):\\n if idx % trainer_count == trainer_id:\\n print(\\\"append file: %s\\\" % fn)\\n my_file_list.append(fn)\\n for fn in my_file_list:\\n with open(fn, \\\"r\\\") as f:\\n lines = loader(f)\\n for line in lines:\\n yield line\\n\\n return reader\",\n \"def parse_parameters(filename):\\n\\n # read in the parameters\\n mainInput = ParserClass.Parser(filename)\\n if 'LogFile' in mainInput['Inputs']:\\n if mainInput['Inputs']['LogFileUsePID']:\\n logger = Logging.Logger(mainInput['Inputs']['LogFile']+'_{}'.format(os.getpid()))\\n else:\\n logger = Logging.Logger(mainInput['Inputs']['LogFile'])\\n \\n else:\\n logger = print\\n\\n # Generate a filelist to loop over\\n filelist = np.loadtxt(mainInput['Inputs']['filelist'],dtype=str,ndmin=1)\\n if isinstance(mainInput['Inputs']['data_dir'], type(None)):\\n filelist = [filename for filename in filelist]\\n else:\\n filelist = ['{}/{}'.format(mainInput['Inputs']['data_dir'],\\n filename.split('/')[-1]) for filename in filelist]\\n \\n # Some items should always be a list\\n if not isinstance(mainInput['Inputs']['pipeline'], list):\\n mainInput['Inputs']['pipeline'] = [mainInput['Inputs']['pipeline']]\\n # Get the class names (modulename, classname)\\n jobnames = [c for c in mainInput['Inputs']['pipeline']]\\n\\n logger('Running: '+' '.join(mainInput['Inputs']['pipeline']))\\n\\n\\n prejobnames = [c for c in mainInput['Inputs']['preamble']]\\n\\n\\n # Read the class parameter file\\n classInput = ParserClass.Parser(mainInput['Inputs']['classParameters'])\\n\\n # Initalise the classes : classInput are the kwargs to initiate classes\\n jobs = []\\n for job in jobnames:\\n jobs += [getClass(job)(logger=logger,**classInput[job])]\\n\\n # Initalise the classes : classInput are the kwargs to initiate classes\\n prejobs = []\\n for prejob in prejobnames:\\n prejobs += [getClass(prejob)(logger=logger,**classInput[prejob])]\\n\\n\\n return jobs,prejobs, filelist, mainInput, classInput, logger\",\n \"def __init__(self, dataset_dir, listfile=None):\\n Reader.__init__(self, dataset_dir, listfile)\\n self._data = [line.split(',') for line in self._data]\\n\\n def process_ihm(x):\\n return list(map(int, x.split(';')))\\n\\n def process_los(x):\\n x = x.split(';')\\n if x[0] == '':\\n return ([], [])\\n return (list(map(int, x[:len(x)//2])), list(map(float, x[len(x)//2:])))\\n\\n def process_ph(x):\\n return list(map(int, x.split(';')))\\n\\n def process_decomp(x):\\n x = x.split(';')\\n if x[0] == '':\\n return ([], [])\\n return (list(map(int, x[:len(x)//2])), list(map(int, x[len(x)//2:])))\\n\\n self._data = [(fname, float(t), process_ihm(ihm), process_los(los),\\n process_ph(pheno), process_decomp(decomp))\\n for fname, t, ihm, los, pheno, decomp in self._data]\",\n \"def read_files(filenames, gram_size=1):\\n assert isinstance(filenames, list), \\\"filenames argument must be a list\\\"\\n parser = MorParser()\\n for fn in filenames:\\n for uid, speaker, ngram in generate_chunks(parser.parse(fn), gram_size):\\n yield fn, uid, speaker, ngram\",\n \"def construct_bibfile_data(*paths):\\n bibs = [reffile_factory(path) for path in paths]\\n return bibs\",\n \"def parseInputFileList (self) :\\n filelist = []\\n try :\\n with open (self.cfgName) as fIn:\\n for line in fIn:\\n line = (line.split(\\\"#\\\")[0]).strip()\\n if line:\\n self.lines.append(line)\\n except IOError:\\n print \\\"*** WARNING: cfg file \\\" , self.cfgName , \\\" not found\\\"\\n return\\n\\n #return filelist\",\n \"def make_input_list(self):\\n input_entries = [i for i in self.params.input if i != None]\\n input_list = []\\n\\n # run through the list of multiple input entries (or just the one) and\\n # concatenate the input list (right now GUI only supplies folder, but\\n # this will change in future)\\n for input_entry in input_entries:\\n if os.path.isfile(input_entry):\\n if input_entry.endswith('.lst'): # read from file list\\n with open(input_entry, 'r') as listfile:\\n listfile_contents = listfile.read()\\n input_list.extend(listfile_contents.splitlines())\\n elif input_entry.endswith(('pickle', 'mccd', 'cbf', 'img')):\\n input_list.append(input_entry) # read in image directly\\n\\n elif os.path.isdir(input_entry):\\n abs_inp_path = os.path.abspath(input_entry)\\n for root, dirs, files in os.walk(abs_inp_path):\\n for filename in files:\\n found_file = os.path.join(root, filename)\\n if found_file.endswith(('pickle', 'mccd', 'cbf', 'img')):\\n input_list.append(found_file)\\n\\n # Pick a randomized subset of images\\n if self.params.advanced.random_sample.flag_on and \\\\\\n self.params.advanced.random_sample.number < len(input_list):\\n inp_list = self.select_random_subset(input_list)\\n else:\\n inp_list = input_list\\n\\n return inp_list\",\n \"def read_file(self, file_name_list):\\n\\n # Iterating over the file name list\\n for file_name in file_name_list:\\n\\n # Opening MTF file\\n #try: \\n mtf_file = open(file_name,\\\"r\\\")\\n #except Exception: pass # TODO\\n\\n # Reading file\\n for line in mtf_file:\\n # Processing line\\n line_list = line.strip().split(\\\"\\\\t\\\")\\n tf_id=line_list[0]\\n name=line_list[1]\\n database=line_list[2]\\n tf_class=int(line_list[3])\\n genes=line_list[4].split(\\\";\\\")\\n genes_suffix=line_list[5].split(\\\";\\\")\\n\\n self.add(Motif(tf_id, name, database, tf_class, genes, genes_suffix))\\n\\n\\n # Termination\\n mtf_file.close()\",\n \"def read_dir():\\n file_list=[]\\n title_list = []\\n for filename in os.listdir(\\\"alignments/\\\"):\\n if filename.endswith(\\\".aln\\\"): #Retrieve only alignment files.\\n file_list.append(filename)\\n with open (\\\"genID.txt\\\",'r') as x: #The genID.txt file contains relevant gene names.\\n while True:\\n rule = x.readline()\\n if len(rule) > 0: #If the rule is empty, the program does not use it.\\n if rule[0] == \\\"B\\\": #Only fetch gen names.\\n title_list.append(rule) #The title_list is used to create the variant files in a later stadium\\n else:\\n break\\n return file_list,title_list\",\n \"def read(self, filenames, encoding=None):\\n if isinstance(filenames, str):\\n filenames = [filenames]\\n read_ok = []\\n for filename in filenames:\\n try:\\n with open(filename, encoding=encoding) as f:\\n self.read_file(f)\\n except OSError:\\n continue\\n read_ok.append(filename)\\n return read_ok\",\n \"def load(cls, filenames, config_factory=Config):\\n return cls([config_factory(f, label=label) for label, f in filenames])\",\n \"def create_read_list(samfile):\\n read_sampler = ReadSampler()\\n for line in samfile:\\n line = sam_utils.SamAlignment(line)\\n vals = line.get_aligned_blocks()\\n if len(vals) > 1:\\n logging.info(\\\"Skipping gapped read %s %s\\\"%(line.QNAME, str(vals))) \\n read_sampler.add_read(vals[0])\\n return read_sampler\",\n \"def __init__(self, _format, name=\\\"Main_list.txt\\\"):\\n self.format = _format\\n self.name = name\\n self.path = self.format + os.sep + self.name\\n self.list = []\\n self.length = 0\",\n \"def files_to_reduce(parameters, evaluate_files):\\n files_to_reduce = []\\n sample = []\\n shear = []\\n\\n if len(evaluate_files) == 0:\\n files_to_reduce.extend(parameters)\\n else:\\n # call function for retrieve the IDs list\\n evaluate_files_l = evaluate_files_list(evaluate_files)\\n for parameter in parameters:\\n if int(parameter['index']) in evaluate_files_l:\\n files_to_reduce.append(parameter['filename'])\\n sample.append(parameter['sample'])\\n shear.append(parameter['shear'])\\n\\n return files_to_reduce, sample, shear\",\n \"def _read_files(self) -> MMD:\\n\\t\\theaders = []\\n\\t\\tbodies = []\\n\\t\\tif self.config.file_type == FileType.CSV:\\n\\t\\t\\tif self.config.source_uris.endswith('.zip'):\\n\\t\\t\\t\\twith ZipFile(self.config.source_uris) as zf:\\n\\t\\t\\t\\t\\tfor item in zf.namelist():\\n\\t\\t\\t\\t\\t\\tif item.endswith('.csv'):\\n\\t\\t\\t\\t\\t\\t\\t# with zf.open(item, 'r') as infile:\\n\\t\\t\\t\\t\\t\\t\\tcsv_reader = csv.reader(TextIOWrapper(zf.open(item, 'r'), 'utf-8'))\\n\\t\\t\\t\\t\\t\\t\\theaders.append(next(csv_reader))\\n\\t\\t\\t\\t\\t\\t\\t# need to find a more efficient way, the csv reader is a generator that can only be used once\\n\\t\\t\\t\\t\\t\\t\\tbodies.append(list(csv_reader))\\n\\t\\t\\telif self.config.source_uris.endswith('.csv'):\\n\\t\\t\\t\\tfor uri in self.config.source_uris:\\n\\t\\t\\t\\t\\tif uri.endswith('.csv'):\\n\\t\\t\\t\\t\\t\\tcsv_reader = csv.reader(open(uri, newline='', encoding='utf-8'))\\n\\t\\t\\t\\t\\t\\theaders.append(next(csv_reader))\\n\\t\\t\\t\\t\\t\\tbodies.append(list(csv_reader))\\n\\t\\telif self.config.file_type == FileType.CNSCHEMA:\\n\\t\\t\\theader = ['@id', 'label_@language', 'label_@value']\\n\\t\\t\\tbody = []\\n\\t\\t\\twith open(self.config.source_uris, 'r') as load_f:\\n\\t\\t\\t\\tload_dict = json.load(load_f)\\n\\t\\t\\t\\theader.extend(load_dict['@context'].keys())\\n\\t\\t\\t\\theader = [h for h in header if h not in ['label', 'range', 'domain', 'subClassOf']]\\n\\t\\t\\t\\ttmp_h = [h for h in header if h not in ['@id', '@language', '@value']]\\n\\t\\t\\t\\tfor item in load_dict['@graph']:\\n\\t\\t\\t\\t\\tif item['@id'].split('/')[-2] == 'resource':\\n\\t\\t\\t\\t\\t\\trow = [item['@id'], item['label']['@language'], item['label']['@value']]\\n\\t\\t\\t\\t\\t\\tfor h in tmp_h:\\n\\t\\t\\t\\t\\t\\t\\tif h in item:\\n\\t\\t\\t\\t\\t\\t\\t\\trow.append(item[h])\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\trow.append(None)\\n\\t\\t\\t\\t\\t\\tbody.append(tuple(row))\\n\\t\\t\\theaders.append(tuple(header))\\n\\t\\t\\tbodies.append(body)\\n\\t\\telif self.config.file_type == FileType.OPENBASE:\\n\\t\\t\\theader = []\\n\\t\\t\\tbody = []\\n\\t\\t\\twith open(self.config.source_uris, 'r') as load_f:\\n\\t\\t\\t\\tfor line in load_f:\\n\\t\\t\\t\\t\\trow = []\\n\\t\\t\\t\\t\\tflat_line = flatten_json(json.loads(line))\\n\\t\\t\\t\\t\\tfor key in flat_line:\\n\\t\\t\\t\\t\\t\\tif key not in header:\\n\\t\\t\\t\\t\\t\\t\\theader.append(key)\\n\\t\\t\\t\\t\\tfor h in header:\\n\\t\\t\\t\\t\\t\\tif h in flat_line:\\n\\t\\t\\t\\t\\t\\t\\trow.append(flat_line[h])\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\trow.append(None)\\n\\t\\t\\t\\t\\tbody.append(row)\\n\\t\\t\\tfor item in body:\\n\\t\\t\\t\\tif len(item) < len(header):\\n\\t\\t\\t\\t\\titem.extend([None for i in range(len(header) - len(item))])\\n\\t\\t\\theaders.append(tuple(header))\\n\\t\\t\\tbodies.append(tuple([tuple(item) for item in body]))\\n\\t\\telif self.config.file_type == FileType.OPENKS:\\n\\t\\t\\t# knowledge graph dataset loading \\n\\t\\t\\tif os.path.exists(self.config.source_uris + '/entities') and os.path.exists(self.config.source_uris + '/triples'):\\n\\t\\t\\t\\theaders = [['entities'], ['triples']]\\n\\t\\t\\t\\tfor file in ['entities', 'triples']:\\n\\t\\t\\t\\t\\ttmp = []\\n\\t\\t\\t\\t\\twith open(self.config.source_uris + '/' + file, 'r') as load_f:\\n\\t\\t\\t\\t\\t\\tfor line in load_f:\\n\\t\\t\\t\\t\\t\\t\\ttmp.append(tuple([item.strip() for item in line.split('\\\\t')]))\\n\\t\\t\\t\\t\\t\\tbodies.append(tuple(tmp))\\n\\t\\t\\t# general text dataset loading\\n\\t\\t\\telif os.path.exists(self.config.source_uris + '/train') and os.path.exists(self.config.source_uris + '/valid'):\\n\\t\\t\\t\\theaders = [['train'], ['valid']]\\n\\t\\t\\t\\tfor file in ['train', 'valid']:\\n\\t\\t\\t\\t\\ttmp = []\\n\\t\\t\\t\\t\\twith open(self.config.source_uris + '/' + file, 'r') as load_f:\\n\\t\\t\\t\\t\\t\\tfor line in load_f:\\n\\t\\t\\t\\t\\t\\t\\ttmp.append(tuple([item.strip() for item in line.split('@@')]))\\n\\t\\t\\t\\t\\t\\tbodies.append(tuple(tmp))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tlogger.warn('Only allows loading with entities and triples for now!')\\n\\t\\t\\t\\traise IOError\\n\\t\\telif self.config.file_type == FileType.NERO:\\n\\t\\t\\theaders = [['unlabeled_data'], ['predict'], ['pattern']]\\n\\t\\t\\tfor file in ['unlabeled_data', 'predict', 'pattern']:\\n\\t\\t\\t\\ttmp = []\\n\\t\\t\\t\\twith open(self.config.source_uris + '/' + file + '.json', 'r') as load_f:\\n\\t\\t\\t\\t\\tfor line in load_f:\\n\\t\\t\\t\\t\\t\\ttmp.append(line.strip())\\n\\t\\t\\t\\t\\tbodies.append(tuple(tmp))\\n\\n\\t\\tmmd.name = self.config.data_name\\n\\t\\tmmd.headers = headers\\n\\t\\tmmd.bodies = bodies\\n\\t\\treturn mmd\",\n \"def read_input_files(self):\\r\\n\\r\\n for input_file in self.list_of_input_files:\\r\\n input_file.read_header_of_file()\\r\\n self.list_of_header_objects.extend(input_file.list_of_header_objects)\\r\\n self.list_of_header_objects_without_ID.extend(input_file.list_of_header_objects_without_ID)\\r\\n self.list_of_contigs.extend(input_file.list_of_contigs)\\r\\n\\r\\n self.list_of_header_objects = list(toolz.unique(self.list_of_header_objects, key=lambda x: x.tag_and_ID))\\r\\n self.list_of_header_objects_without_ID = list(\\r\\n toolz.unique(self.list_of_header_objects_without_ID, key=lambda x: x.line))\\r\\n self.list_of_contigs = list(toolz.unique(self.list_of_contigs, key=lambda x: x.line))\\r\\n self.list_of_header_objects.extend(self.list_of_header_objects_without_ID)\\r\\n self.list_of_header_objects.sort(key=lambda x: x.line)\\r\\n self.list_of_header_objects.extend(self.list_of_contigs)\\r\\n self.list_of_header_objects.sort(key=lambda x: x.tag, reverse=False)\\r\\n self.create_body_header_line_for_output()\\r\\n self.write_header_in_output_file()\\r\\n\\r\\n list_of_chrom = list(self.indices.keys())\\r\\n list_of_chrom.sort(key=lambda x: self.alphanum_key(x))\\r\\n for chrom in list_of_chrom:\\r\\n self.list_of_body_objects.clear()\\r\\n for input_file in self.list_of_input_files:\\r\\n input_file.read_specific_chrom_body_of_file(chrom)\\r\\n self.list_of_body_objects.extend(input_file.list_of_body_objects)\\r\\n\\r\\n self.adjust_body_records_to_samples()\\r\\n self.list_of_body_objects = list(toolz.unique(self.list_of_body_objects, key=lambda x: x.line))\\r\\n self.list_of_body_objects.sort(key=lambda x: self.alphanum_key(x.line))\\r\\n self.verify_and_merge_body_records()\\r\\n self.write_specific_chrom_in_output_file()\",\n \"def initialize_files(file_name, ran, file_extension):\\r\\n \\\"\\\"\\\"Specifiy the exact file name and the number of files --> file_name_(range) e.g file_name=chickens ,ran=16\\\"\\\"\\\"\\r\\n answer_file_rep = [file_name + str(number) for number in range(1, ran)]\\r\\n answer_files = [file + \\\"{}\\\".format(file_extension) for file in answer_file_rep]\\r\\n answers = [\\\"answer\\\" + str(number) for number in range(1, ran)]\\r\\n return answer_files, ran, answers\",\n \"def from_filenames(\\n filenames,\\n verbose=False,\\n unhandled=None,\\n compare_beam=None,\\n compare_detector=None,\\n compare_goniometer=None,\\n scan_tolerance=None,\\n format_kwargs=None,\\n load_models=True,\\n ):\\n experiments = ExperimentList()\\n for db in DataBlockFactory.from_filenames(\\n filenames,\\n verbose=verbose,\\n unhandled=unhandled,\\n compare_beam=compare_beam,\\n compare_detector=compare_detector,\\n compare_goniometer=compare_goniometer,\\n scan_tolerance=scan_tolerance,\\n format_kwargs=format_kwargs,\\n ):\\n experiments.extend(\\n ExperimentListFactory.from_datablock_and_crystal(db, None, load_models)\\n )\\n return experiments\",\n \"def loadFromFile(self, filename):\\n\\t\\treturn []\",\n \"def _open_files(inputs, mode):\\n assert isinstance(inputs, list)\\n\\n local_open = pf.open\\n return [local_open(ffile, mode=mode) for ffile in inputs]\",\n \"def read_in_LC_files(input_files, obj_names, style='SNANA'):\\n LC_list = []\\n if style == 'SNANA':\\n for i, input_file in enumerate(input_files):\\n t, f, filts, err = np.genfromtxt(input_file,\\n usecols=(1, 4, 2, 5), skip_header=18,\\n skip_footer=1, unpack=True, dtype=str)\\n t = np.asarray(t, dtype=float)\\n f = np.asarray(f, dtype=float)\\n err = np.asarray(err, dtype=float)\\n\\n sn_name = obj_names[i]\\n new_LC = LightCurve(sn_name, t, f, err, filts)\\n LC_list.append(new_LC)\\n else:\\n raise ValueError('Sorry, you need to specify a data style.')\\n return LC_list\",\n \"def buildfilelist():\\r\\n for files in filelist:\\r\\n if os.path.splitext(files)[1]=='.dxf': #查找目录下的dxf文件，加入到readfilelist文件列表中 \\r\\n readfilelist.append(files)\\r\\n #feilin=file('feilin(ph).dxf','w') #新建一个文件，名字先占位用，后续改成由配置文件中读入名称。 \\r\",\n \"def parse_files(files):\\n ans = []\\n if files:\\n for f in files:\\n split = f.split(\\\"=\\\")\\n if len(split) != 2:\\n raise Exception(\\\"invalid file specification '%s'\\\" % f)\\n ans.append((split[0], split[1]))\\n return ans\",\n \"def read(self, filenames):\\n if isinstance(filenames, basestring):\\n filenames = [filenames]\\n read_ok = []\\n for filename in filenames:\\n try:\\n fp = open(filename)\\n except IOError:\\n continue\\n self._read(fp, filename)\\n fp.close()\\n read_ok.append(filename)\\n return read_ok\",\n \"def Make_FileList(input_name):\\n\\tif args.input_type == 'FILE':\\n\\t\\tFileList=[]\\n\\t\\tFileList.append(input_name)\\n\\tif args.input_type == 'FOLDER':\\n\\t\\tFileList = glob.glob('%s/*' % input_name)\\n\\treturn FileList\",\n \"def __init__(self):\\n self.filelist = list()\",\n \"def files_list_reduce(filename, fieldnames):\\n\\n parameters = []\\n with open(filename) as csv_file:\\n\\n reader = csv.DictReader(csv_file, fieldnames=fieldnames)\\n iterRows = iter(reader)\\n next(iterRows)\\n for row in iterRows:\\n if row['index'] == '':\\n continue\\n if row['index'] == 'END':\\n break\\n parameters.append(row)\\n return parameters\",\n \"def read(self,filenames):\\n\\n if isinstance(filenames, basestring):\\n filenames = [filenames]\\n read_ok = []\\n for filename in filenames:\\n try:\\n fp = open(filename)\\n except IOError:\\n continue\\n self._read(fp)\\n fp.close()\\n read_ok.append(filename)\\n return read_ok\",\n \"def get_data(methylation_files, names, window, smoothen=5):\\n return [read_meth(f, n, window, smoothen) for f, n in zip(methylation_files, names)]\",\n \"def read_data(r_filename, nr_filename, config):\\n\\t\\n\\t# Create a queue for each file\\n\\tr_queue = tf.train.string_input_producer(r_filename)\\n\\tnr_queue = tf.train.string_input_producer(nr_filename)\\n\\n\\tr_result = _read_from_file(r_queue, config, class_label = 1)\\n\\tnr_result = _read_from_file(nr_queue, config, class_label = 0)\\n\\n\\tmin_queue_examples = 100 # Currently an arbitrary number\\n\\n\\tr_sequences, r_label_batch, r_subjects, r_names, r_coords, r_features = _generate_half_batch(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tr_result,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tmin_queue_examples,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tbatch_size = config.batch_size,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tnum_steps = config.num_steps,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttest_mode = config.test_mode)\\n\\tnr_sequences, nr_label_batch, nr_subjects, nr_names, nr_coords, nr_features = _generate_half_batch(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tnr_result,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tmin_queue_examples,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tbatch_size = config.batch_size,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tnum_steps = config.num_steps,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttest_mode = config.test_mode)\\n\\n\\tsequence_batches_joined = tf.concat([r_sequences, nr_sequences], 0)\\n\\tlabel_batches_joined = tf.concat([r_label_batch, nr_label_batch], 0)\\n\\tsubjects_batches_joined = tf.concat([r_subjects, nr_subjects], 0)\\n\\tnames_batches_joined = tf.concat([r_names, nr_names], 0)\\n\\tcoords_batches_joined = tf.concat([r_coords, nr_coords], 0)\\n\\tfeature_batches_joined = tf.concat([r_features, nr_features], 0)\\n\\n\\treturn sequence_batches_joined, label_batches_joined, subjects_batches_joined, names_batches_joined, coords_batches_joined, feature_batches_joined\",\n \"def open_netcdf_files(rlzn_path_list,name_prefix): #{{{\\n\\n fopen_list = []\\n for path in rlzn_path_list:\\n netcdf_name = glob.glob(path+'/'+name_prefix)\\n fopen_list.append(netCDF4.Dataset(netcdf_name[0],'r'))\\n\\n return fopen_list #}}}\",\n \"def _generate_examples(self, files):\\n idx = 0\\n for filename in files:\\n with open(filename) as file:\\n for line in file:\\n yield idx, {\\\"text\\\": line}\\n idx += 1\",\n \"def build_file_list(location, filters):\\n f = []\\n for (dir_path, dir_name, file_names) in os.walk(location):\\n for file in file_names:\\n f.append(os.path.join(dir_path, file))\\n obj_list = map(lambda file: os.path.join(location, file), f)\\n\\n if type(filters) == list:\\n for filter in filters:\\n obj_list = [i for i in obj_list if filter in i]\\n else:\\n obj_list = [i for i in obj_list if filters in i]\\n\\n return obj_list\",\n \"def prepare_list_of_files(kernel_name, kernel_file_list, params, grid, threads, block_size_names):\\n temp_files = dict()\\n\\n kernel_string = get_kernel_string(kernel_file_list[0], params)\\n name, kernel_string = prepare_kernel_string(kernel_name, kernel_string, params, grid, threads, block_size_names)\\n\\n if len(kernel_file_list) > 1:\\n for f in kernel_file_list[1:]:\\n #generate temp filename with the same extension\\n temp_file = get_temp_filename(suffix=\\\".\\\" + f.split(\\\".\\\")[-1])\\n temp_files[f] = temp_file\\n #add preprocessor statements to the additional file\\n _, temp_file_string = prepare_kernel_string(kernel_name, get_kernel_string(f, params), params, grid, threads, block_size_names)\\n write_file(temp_file, temp_file_string)\\n #replace occurences of the additional file's name in the first kernel_string with the name of the temp file\\n kernel_string = kernel_string.replace(f, temp_file)\\n\\n return name, kernel_string, temp_files\",\n \"def generate_read_list(num_files, world_size):\\n return np.array_split(np.arange(num_files), world_size)\",\n \"def prepare_reader(self, unused_filename_queue):\\n raise NotImplementedError()\",\n \"def get_file_list(mixer_file, select_random, use_list_of_files):\\n logger = logging.getLogger(get_file_list.__name__)\\n files = list()\\n\\n if use_list_of_files:\\n with open(mixer_file, 'r') as list_file:\\n for line in list_file:\\n files.append(os.path.join('data/raw',line.strip()))\\n\\n if select_random:\\n random.shuffle(files)\\n\\n else:\\n\\n mixer = parse_mixer_file(mixer_file)\\n\\n for m in mixer:\\n path = os.path.join(project_dir, m[0])\\n all_mixer_files = [os.path.join(path,f) for f in os.listdir(path) \\n if os.path.isfile(os.path.join(path, f)) and f.split('.')[-1] == 'csv']\\n\\n current_files = list()\\n # Check if the number of samples is limited\\n if m[2] >= 0:\\n sample_count = 0\\n for f in all_mixer_files:\\n # Get number of lines without the header line\\n num_lines = sum(1 for line in open(f)) - 1\\n\\n if (sample_count + num_lines) > m[2]:\\n current_files.append((f, m[2] - sample_count))\\n sample_count += (m[2] - sample_count)\\n break\\n else:\\n current_files.append((f, -1))\\n sample_count += num_lines\\n\\n if sample_count < m[2]:\\n logger.warn('Not enough samples ({} < {}): {}'.format(sample_count, m[2], m[0]))\\n else:\\n # No limit, take all samples in the files\\n current_files = zip(all_mixer_files, [-1]*len(all_mixer_files))\\n\\n if m[1] < 0:\\n # -1 means all .csv files\\n files += current_files\\n elif m[1] > 0:\\n if m[1] > len(current_files):\\n logger.warn('Not enough files ({} < {}): {}'.format(len(current_files),\\n m[1], m[0]))\\n files += current_files[:m[1]]\\n\\n if select_random:\\n random.shuffle(files)\\n else:\\n files = sorted(files, key=lambda x: int(os.path.basename(x[0]).split('_')[-1].split('.')[0]))\\n\\n return files\",\n \"def _create_filelist(self):\\n print \\\"[--init] creating %s\\\" % self.file_list\\n if self.source_file is not None:\\n shutil.copyfile(self.source_file, self.file_list)\\n elif self.source_path is not None:\\n filenames = get_file_paths(self.source_path)\\n if self.shuffle_file:\\n random.shuffle(filenames)\\n with open(self.file_list, 'w') as fh:\\n for fname in filenames:\\n fh.write(\\\"0000\\\\t\\\" + fname + \\\"\\\\n\\\")\\n else:\\n sys.exit(\\\"[--init] ERROR: \\\" +\\n \\\"need to define input with --filelist or \\\" +\\n \\\"--source-directory option, aborting\\\")\\n read_only(self.file_list)\",\n \"def __init__(self, names, file_extensions, version):\\n assert isinstance(names, collections.abc.Sequence), type(names)\\n assert names\\n assert isinstance(file_extensions, collections.abc.Sequence), type(file_extensions)\\n assert file_extensions\\n if __debug__:\\n for name in names:\\n assert isinstance(name, str), type(name)\\n assert name\\n for file_extension in file_extensions:\\n assert isinstance(file_extension, str), type(file_extension)\\n assert file_extension\\n assert file_extension.startswith('.'), file_extension\\n assert isinstance(version, tuple) or version is None\\n self.names = [name for name in names]\\n self.default_name = self.names[0]\\n self.file_extensions = [file_extension.lower() for file_extension in file_extensions]\\n self.default_file_extension = self.file_extensions[0]\\n self.version = version\",\n \"def parse_from_list(l, os_name=None):\\n\\n if os_name in ['windows', 'nt']:\\n FilePathObject = WindowsFilePath\\n elif os_name in ['posix', 'linux']:\\n FilePathObject = PosixFilePath\\n else:\\n raise ValueError('incorrect os_name given')\\n\\n if not isinstance(l, (list, tuple)):\\n raise ValueError('expect a list with filepaths')\\n\\n l_args = map(lambda x: tuple(x) if isinstance(\\n x, (tuple, list)) else tuple([x]), l)\\n\\n return [FilePathObject(*fp) for fp in l_args]\",\n \"def read_parse_file(params):\\n\\tparam_names = []\\n\\tparam_options = []\\n\\tif not os.path.isfile(params.parse_file):\\n\\t\\tprint(\\\"parse file does not exist! ({})\\\".format(params.parse_file))\\n\\t\\tsys.exit(NO_PARSE)\\n\\twith open(params.parse_file, 'r') as pf:\\n\\t\\t# first line should be iteration regex\\n\\t\\tsetattr(params, 'iteration_regex', re.compile(pf.readline().strip()))\\n\\t\\tfor line in pf:\\n\\t\\t\\tparam_desc = line.split(';')\\n\\t\\t\\tparam_names.append(param_desc[0])\\n\\t\\t\\tparam_options.append(param_desc[1])\\n\\n\\treturn param_names,param_options\",\n \"def readFiles(trainFile, testFile):\\r\\n\\r\\n\\t# Open both files and split into lines\\r\\n\\twith open(trainFile) as f:\\r\\n\\t\\ttrainLines = f.read().splitlines()\\r\\n\\r\\n\\twith open(testFile) as f:\\r\\n\\t\\ttestLines = f.read().splitlines()\\r\\n\\r\\n\\t\\t\\r\\n\\t# Extract training data\\r\\n\\tfor line in trainLines:\\r\\n\\t\\tline = line.split()\\r\\n\\t\\t\\r\\n\\t\\tid = line[0]\\r\\n\\t\\tclass_id = line[1]\\r\\n\\t\\twords = line[2:]\\r\\n\\t\\t\\r\\n\\t\\trow = [id, class_id, words]\\r\\n\\t\\t\\r\\n\\t\\ttrainingData.append(row)\\r\\n\\t\\t\\r\\n\\t\\t\\r\\n\\t# Extract testing data\\r\\n\\tfor line in testLines:\\r\\n\\t\\tline = line.split()\\r\\n\\t\\t\\r\\n\\t\\tid = line[0]\\r\\n\\t\\tclass_id = line[1]\\r\\n\\t\\twords = line[2:]\\r\\n\\t\\t\\r\\n\\t\\trow = [id, class_id, words]\\r\\n\\t\\t\\r\\n\\t\\ttestData.append(row)\",\n \"def generate_reader(n):\\n counter = 1\\n for i in range(n):\\n name = generate_reader_name()\\n if not name in readers:\\n readers[name] = f'Reader/{counter}'\\n counter += 1\",\n \"def _read_dataset(a_files):\\n return [(list(ifields[TXT_IDX]), ifields[GLD_IDX])\\n for ifile in a_files for ifields in iterlines(ifile)]\",\n \"def __init__(self, dataset_dir, listfile=None, period_length=48.0):\\n Reader.__init__(self, dataset_dir, listfile)\\n self._data = [line.split(\\\",\\\") for line in self._data]\\n self._data = [(x, int(y)) for (x, y) in self._data]\\n self._period_length = period_length\",\n \"def construct_combined_set(filenames, sensor_names, cnt_preprocessors,\\n marker_def, end_marker_def, trial_classes,\\n trial_start_offset_ms, trial_stop_offset_ms,\\n min_break_length_ms, max_break_length_ms,\\n break_start_offset_ms, break_stop_offset_ms,\\n last_set_split_trial, add_trial_breaks=True,\\n filename_to_extra_args=None):\\n default_args = deepcopy(locals())\\n sets = []\\n\\n if filename_to_extra_args is not None:\\n for filename_with_args in filename_to_extra_args:\\n assert filename_with_args in filenames\\n\\n for i_file, filename in enumerate(filenames):\\n this_args = copy(default_args)\\n if filename_to_extra_args is not None and (\\n filename in filename_to_extra_args):\\n for key in filename_to_extra_args[filename]:\\n assert key in this_args\\n this_args[key] = filename_to_extra_args[filename][key]\\n assert key != 'last_set_split_trial', \\\"Does not make sense :)\\\"\\n marker_segmenter = MarkerSegmenter(segment_ival=[\\n this_args['trial_start_offset_ms'], \\n this_args['trial_stop_offset_ms']],\\n marker_def=this_args['marker_def'],\\n trial_classes=this_args['trial_classes'],\\n end_marker_def=this_args['end_marker_def'])\\n trial_break_adder = AddTrialBreaks(min_length_ms=this_args['min_break_length_ms'],\\n max_length_ms=this_args['max_break_length_ms'], \\n start_offset_ms=this_args['break_start_offset_ms'], \\n stop_offset_ms=this_args['break_stop_offset_ms'],\\n start_marker_def=this_args['marker_def'],\\n end_marker_def=this_args['end_marker_def'])\\n if (i_file < len(filenames) - 1) or (\\n this_args['last_set_split_trial'] is None):\\n segmenters = [marker_segmenter,]\\n else:\\n segmenters = [marker_segmenter,\\n RestrictTrialRange(0,this_args['last_set_split_trial'])]\\n if this_args['add_trial_breaks']:\\n segmenters.append(trial_break_adder)\\n segmenter = PipelineSegmenter(segmenters)\\n cnt_set = SetWithMarkers(BBCIDataset(filename,\\n load_sensor_names=this_args['sensor_names']),\\n this_args['cnt_preprocessors'],\\n segmenter) \\n sets.append(cnt_set)\\n\\n # add last set last part as test set if you split apart last set\\n # we use that this_args is now from last set already\\n if last_set_split_trial is not None:\\n segmenters = [marker_segmenter,\\n RestrictTrialRange(last_set_split_trial,None),]\\n if this_args['add_trial_breaks']:\\n segmenters.append(trial_break_adder)\\n segmenter = PipelineSegmenter(segmenters)\\n cnt_set = SetWithMarkers(BBCIDataset(filenames[-1], # again last file needed\\n load_sensor_names=this_args['sensor_names']),\\n this_args['cnt_preprocessors'],\\n segmenter)\\n sets.append(cnt_set)\\n dataset = CombinedSet(sets)\\n return dataset\",\n \"def buildRegFilterList(self, filename, listname='regFilterList'):\",\n \"def read_list_file(path_file):\\n with open(path_file,'r') as f_in:\\n lines = f_in.readlines()\\n lines = [x for x in lines if not (x.strip() == '' or x.strip()[0] == '#')]\\n left_file_list = []\\n right_file_list = []\\n gt_file_list = []\\n conf_file_list = []\\n for l in lines:\\n to_load = re.split(',|;',l.strip())\\n left_file_list.append(to_load[0])\\n right_file_list.append(to_load[1])\\n if len(to_load)>2:\\n gt_file_list.append(to_load[2])\\n if len(to_load)>3:\\n conf_file_list.append(to_load[3])\\n return left_file_list,right_file_list,gt_file_list,conf_file_list\",\n \"def from_file_list(\\n cls,\\n audio_file_list,\\n target_sr=None,\\n int_values=False,\\n offset=0,\\n duration=0,\\n trim=False,\\n channel_selector=None,\\n *args,\\n **kwargs,\\n ):\\n if isinstance(channel_selector, int):\\n # Shortcut when selecting a single channel\\n if channel_selector >= len(audio_file_list):\\n raise RuntimeError(\\n f'Channel cannot be selected: channel_selector={channel_selector}, num_audio_files={len(audio_file_list)}'\\n )\\n # Select only a single file\\n audio_file_list = [audio_file_list[channel_selector]]\\n # Reset the channel selector since we applied it here\\n channel_selector = None\\n\\n samples = None\\n\\n for a_file in audio_file_list:\\n # Load audio from the current file\\n a_segment = cls.from_file(\\n a_file,\\n target_sr=target_sr,\\n int_values=int_values,\\n offset=offset,\\n duration=duration,\\n channel_selector=None,\\n trim=False, # Do not apply trim to individual files, it will be applied to the concatenated signal\\n *args,\\n **kwargs,\\n )\\n\\n # Only single-channel individual files are supported for now\\n if a_segment.num_channels != 1:\\n raise RuntimeError(\\n f'Expecting a single-channel audio signal, but loaded {a_segment.num_channels} channels from file {a_file}'\\n )\\n\\n if target_sr is None:\\n # All files need to be loaded with the same sample rate\\n target_sr = a_segment.sample_rate\\n\\n # Concatenate samples\\n a_samples = a_segment.samples[:, None]\\n\\n if samples is None:\\n samples = a_samples\\n else:\\n # Check the dimensions match\\n if len(a_samples) != len(samples):\\n raise RuntimeError(\\n f'Loaded samples need to have identical length: {a_samples.shape} != {samples.shape}'\\n )\\n\\n # Concatenate along channel dimension\\n samples = np.concatenate([samples, a_samples], axis=1)\\n\\n # Final setup for class initialization\\n samples = np.squeeze(samples)\\n sample_rate = target_sr\\n\\n return cls(\\n samples, sample_rate, target_sr=target_sr, trim=trim, channel_selector=channel_selector, *args, **kwargs,\\n )\",\n \"def __init__(self, dataset_dir, listfile=None, period_length=48.0):\\n Reader.__init__(self, dataset_dir, listfile)\\n self._data = [line.split(',') for line in self._data]\\n self._data = [(x, int(y)) for (x, y) in self._data]\\n self._period_length = period_length\",\n \"def __init__(self, filename, listfile=True):\\n if hasattr(filename, 'read'):\\n self.file = filename\\n else:\\n self.file = open(filename, 'rb')\\n self.header = self.read_header()\\n self.hash_table = self.read_table('hash')\\n self.block_table = self.read_table('block')\\n if listfile:\\n self.files = self.read_file('(listfile)').splitlines()\\n else:\\n self.files = None\",\n \"def __init__(self, dataset_dir, listfile=None):\\n Reader.__init__(self, dataset_dir, listfile)\\n self._data = [line.split(',') for line in self._data]\\n self._data = [(mas[0], float(mas[1]), list(map(int, mas[2:]))) for mas in self._data]\",\n \"def __init__(self,file_reader):\\n self.file_reader = file_reader\",\n \"def mk_parses(listfile, corenlp_host):\\n # if not listfile.endswith('.listfile'):\\n # filetype = 'Co-Reference List file'\\n # error = 'has incorrect file type'\\n # raise FilenameException(\\\"Error: %s %s\\\" % (filetype, error))\\n\\n try:\\n with open(listfile) as f:\\n pserver = jsonrpc.ServerProxy(jsonrpc.JsonRpc20(),\\n jsonrpc.TransportTcpIp(\\n addr=(corenlp_host, 8080), limit=1000))\\n parses = dict([(get_id(path), FileParse(path, pserver))\\n for path in f.readlines()\\n if path.lstrip()[0] != '#'])\\n except IOError:\\n stderr.write(strerror(EIO)) # stderr.write does not have newlines\\n stderr.write(\\\"\\\\nERROR: Could not open list file\\\\n\\\")\\n exit(EIO)\\n else:\\n return parses\",\n \"def fileReader(self, fileHouses, fileBatteries):\\n\\n # Initiate ID\\n ID = 0\\n\\n # Open the file containing houses\\n with open(fileHouses) as h, open(fileBatteries) as b:\\n\\n # Read the file and separate values in list\\n readerHouses = csv.reader(h, delimiter=',', quoting=csv.QUOTE_NONE)\\n readerBatteries = csv.reader(b, delimiter=',',\\n quoting=csv.QUOTE_NONE)\\n\\n # Skip the header of the file\\n next(h)\\n next(b)\\n\\n # Create instances of houses or batteries\\n for row in readerHouses:\\n self.houses.append(houseClass.house(ID, int(row[0]),\\n int(row[1]),\\n float(row[2])))\\n ID += 1\\n\\n ID = 0\\n\\n for row in readerBatteries:\\n self.batteries.append(batteryClass.battery(ID, int(row[0]),\\n int(row[1]), float(row[2])))\\n ID += 1\",\n \"def list(ffiles):\\n ret = {}\\n print('Reading: ')\\n for ffile in ffiles:\\n print(ffile)\\n ret[ffile] = data_file(ffile)\\n return ret\",\n \"def from_files(paths: list[str]) -> Catalog:\\n cat = Catalog()\\n for file in paths:\\n with fsspec.open(file, mode=\\\"r\\\") as fh:\\n new_cat = Catalog.from_str(fh.read())\\n cat = cat.join(new_cat)\\n return cat\",\n \"def _open_files(path, filenames, barcode, queue):\\n if not exists(path):\\n mkdir(path)\\n\\n handles = []\\n\\n for filename in filenames:\\n base, ext = basename(filename).split('.', True)\\n handles.append(\\n Handle('{}/{}_{}.{}'.format(path, base, barcode, ext), queue,\\n f_open=_type_handler[ext.split('.')[-1]]))\\n\\n return handles\",\n \"def read_files(self):\\n for f in self.filenames:\\n self.games.extend(pgn.loads(open(f).read()))\",\n \"def build_data_from_file(cls,file_path,number_elems=None):\\n raise NotImplementedError('Abstract method has not been implemented')\",\n \"def load_files(basis_handles, parameter_handles):\\n\\n logging.info('Loading basis matrices')\\n\\n bases = [load_basis(handle) for handle in basis_handles]\\n\\n logging.info('Loading scaling parameters')\\n\\n parameters = [load_parameters(handle) for handle in parameter_handles]\\n\\n return bases, parameters\",\n \"def load_training_data(list_files):\\n training_data = []\\n for tr_file in list_files:\\n with open(os.path.join(\\\"data\\\", tr_file)) as csv_file:\\n reader = csv.reader(csv_file, delimiter=\\\",\\\")\\n next(reader)\\n for row in reader:\\n training_data.append(row[1])\\n return training_data\",\n \"def read_files(self):\\n files = []\\n # if this is test folder then there are no labels\\n if 'test' in self.list_path:\\n for item in self.img_list:\\n image_path = item\\n name = os.path.splitext(os.path.basename(image_path[0]))[0]\\n files.append({\\n \\\"img\\\": image_path[0],\\n \\\"name\\\": name,\\n })\\n else:\\n for item in self.img_list:\\n image_path, label_path = item\\n name = os.path.splitext(os.path.basename(label_path))[0]\\n files.append({\\n \\\"img\\\": image_path,\\n \\\"label\\\": label_path,\\n \\\"name\\\": name,\\n \\\"weight\\\": 1\\n })\\n return files\",\n \"def parseInputFileList (self):\\n filelist = []\\n try:\\n with open (self.cfgName) as fIn:\\n for line in fIn:\\n line = (line.split(\\\"@@@\\\")[0]).strip()\\n if line:\\n self.lines.append(line)\\n except IOError:\\n print \\\"*** WARNING: label cfg file \\\" , self.cfgName , \\\" not found\\\"\\n return\",\n \"def Load_trials(files=[], trials=[]):\\n\\n # adds each file to files list\\n\\n while True:\\n new_file = Add_file(files)\\n if new_file:\\n files.append(new_file)\\n else:\\n break\\n\\n for file in files:\\n try:\\n ff = open(file)\\n failed_to_read_counter = 0\\n ff.readline() # skips the title line\\n line_read_counter = 0\\n while True:\\n line_read_counter += 1\\n try:\\n line = ff.readline()\\n except:\\n failed_to_read_counter += 1\\n continue\\n # breaks at last line\\n if not line:\\n break\\n else:\\n # splits by tabs\\n try:\\n fields = line.split(\\\"\\\\t\\\")\\n rank = int(fields[0])\\n except:\\n continue\\n # instances a new trial for each line and includes in list of trials\\n trial = (\\n Trial.add_trial(rank, fields[1], fields[2], fields[3], fields[4], fields[5], fields[6], fields[7],\\n file))\\n ff.close()\\n finally:\\n a=0\\n return trials\",\n \"def load_from_files(*filenames,**kwargs):\\n if 'keys' in kwargs.keys() and 'dtype' not in kwargs.keys():\\n raise ValueError('Please set dtype as well.')\\n elif 'keys' in kwargs.keys() and 'dtype' in kwargs.keys():\\n if len(kwargs['keys']) != len(kwargs['dtype']):\\n raise ValueError('Length of keys and dtype must match.')\\n\\n z_range = kwargs.pop('z_range',None)\\n z_key = kwargs.pop('z_key',None)\\n keys = kwargs.pop('keys',['Name','RA','Dec','z'])\\n dtypes = kwargs.pop('dtype',[object,float,float,float])\\n case_sensitive = kwargs.pop('case_sensitive',False)\\n comments = kwargs.pop('comments','#')\\n delimiter = kwargs.pop('delimeter',None)\\n return_fileindex = kwargs.pop('return_fileindex',False)\\n\\n if kwargs != {}:\\n unknown_kw = ' '.join(kwargs.keys())\\n raise TypeError('load_from_files got unknown keyword arguments: {}'.format(unknown_kw))\\n\\n if not case_sensitive:\\n keys = [a.upper() for a in keys]\\n\\n if z_range is not None and z_key is None:\\n z_keys = [key for key in keys \\n if key[0].upper() == 'Z' or key.upper() == \\\"REDSHIFT\\\"] \\n if len(z_keys) == 0:\\n raise ValueError('Failed to determine z_key, please set kwarg z_key')\\n elif len(z_keys) > 1:\\n raise ValueError('Ambiguous z_key, please set kwargs z_key manually')\\n else:\\n z_key = z_keys[0]\\n\\n out = None\\n fileindex = []\\n\\n for k,filename in enumerate(filenames):\\n tmp = np.genfromtxt(filename,names=True,comments=comments,dtype=None,\\n case_sensitive=case_sensitive,delimiter=delimiter)\\n \\n if z_range is None:\\n tmp2 = np.zeros((len(tmp),),dtype=zip(keys,dtypes))\\n fileindex.extend([k for a in range(len(tmp))])\\n for key in keys:\\n tmp2[key] = tmp[key]\\n else:\\n z_filter = (tmp[z_key] >= z_range[0]) & (tmp[z_key] < z_range[1]) \\n tmp2 = np.zeros((np.sum(z_filter),),dtype=zip(keys,dtypes))\\n fileindex.extend([k for a in range(np.sum(z_filter))])\\n for key in keys:\\n tmp2[key] = tmp[key][z_filter]\\n \\n if out is None:\\n out = tmp2\\n else:\\n out = np.concatenate((out,tmp2))\\n \\n if return_fileindex:\\n return [out[key] for key in keys] + [np.array(fileindex)]\\n else:\\n return [out[key] for key in keys]\",\n \"def get_movie_data(files: list) -> list:\\n pass\",\n \"def file_reader(filename = 'conv_params'):\\n\\n with open(filename) as f:\\n info = f.readlines()\\n info = [i.strip() for i in info] # each element in info is a string of a line from the file\\n info = [i.split() for i in info] # split each whitespace delimited element into a list of lists\\n info = [[i.split('-') for i in j] for j in info] # note info is 3 layers deep\\n\\n info[2] = info[2][0] # makes default E just a single string of the number\\n info[3] = info[3][0]\\n\\n return info\",\n \"def from_files(cls, mos_file_paths, *, allow_incomplete=False):\\n logger.info(\\\"Making MosCollection from %s files\\\", len(mos_file_paths))\\n mos_readers = sorted([\\n mr\\n for mr in [MosReader.from_file(mfp) for mfp in mos_file_paths]\\n if mr is not None\\n ])\\n return cls(mos_readers, allow_incomplete=allow_incomplete)\",\n \"def mkfilelist(filesN, filesE):\\n newlist = []\\n for _fN in filesN:\\n for _fE in filesE:\\n trN = SacIO(_fN, headonly=True)\\n stN = trN.kstnm.rstrip()\\n dtN = trN.delta\\n trE = SacIO(_fE, headonly=True)\\n stE = trE.kstnm.rstrip()\\n dtE = trE.delta\\n if stN == stE:\\n if dtE != dtN:\\n print \\\"sampling intervals are not identical for %s and %s\\\" % (_fN, _fE)\\n break\\n else:\\n newlist.append((_fN, _fE))\\n break\\n\\n return newlist, 1. / dtN\",\n \"def read_model_list(self,filename):\\n\\n self.grid_params = config.grid_params\\n\\n # set the correct dimension:\\n self.ndim = len(self.grid_params)\\n\\n # set prefix and postfix:\\n listfile = open(filename,\\\"r\\\")\\n line = listfile.readline().strip();\\n columns = line.split()\\n if (len(columns) < 1): sys.exit(\\\"Erroneous first line in %s.\\\"%(filename))\\n self.prefix = columns[0]\\n if (len(columns) > 1): self.postfix = columns[1]\\n\\n # read models and put them into evolutionary tracks:\\n nmodels = 0\\n nmodes = 0\\n models_small_spectra = []\\n for line in listfile:\\n line = line.strip()\\n columns = line.split()\\n glb = np.empty((nglb,),dtype = gtype)\\n glb[imass] = utilities.to_float(columns[1])\\n glb[iradius] = utilities.to_float(columns[2])\\n glb[iluminosity] = utilities.to_float(columns[3])\\n glb[iz0] = utilities.to_float(columns[4])\\n glb[ix0] = utilities.to_float(columns[5])\\n glb[iage] = utilities.to_float(columns[6])\\n glb[itemperature] = utilities.to_float(columns[7])\\n\\n i = 8\\n for (name, name_latex) in config.user_params:\\n glb[user_params_index[name]] = utilities.to_float(columns[i])\\n i += 1\\n\\n # print glb[0]\\n aModel = Model(glb, _name = columns[0])\\n exceed_freqlim = aModel.read_file(self.prefix + columns[0] + self.postfix)\\n aModel.multiply_modes(1.0/aModel.glb[ifreq_ref]) # make frequencies non-dimensional\\n aModel.sort_modes()\\n aModel.remove_duplicate_modes()\\n for track in self.tracks:\\n if (track.matches(aModel)):\\n track.append(aModel)\\n break\\n else:\\n aTrack = Track(aModel,self.grid_params)\\n self.tracks.append(aTrack)\\n nmodels += 1\\n nmodes += len(aModel.modes)\\n if (not exceed_freqlim):\\n models_small_spectra.append(aModel.name)\\n print(nmodels, nmodes)\\n listfile.close()\\n\\n # right list of models with spectra which are too small in a file:\\n output = open(\\\"models_small_spectra\\\",\\\"w\\\")\\n for name in models_small_spectra: output.write(name+\\\"\\\\n\\\")\\n output.close()\\n\\n # sort tracks:\\n for track in self.tracks: track.sort()\\n\\n # sanity check:\\n for track in self.tracks:\\n duplicate = track.duplicate_ages()\\n if duplicate[0]:\\n print(\\\"ERROR: the track \\\",track.grid_params,\\\" = \\\",track.params)\\n print(\\\" has models with the same age. Please remove\\\")\\n print(\\\" duplicate models.\\\")\\n print(\\\" Check models:\\\", duplicate[1], duplicate[2])\\n sys.exit(1)\\n\\n # update list of indices:\\n self.ndx = range(len(self.tracks))\\n\\n # need to create grid from scratch since tracks have been sorted.\\n self.grid = np.asarray([track.params for track in self.tracks])\",\n \"def from_args(args, verbose=False, unhandled=None):\\n\\n # Create a list for unhandled arguments\\n if unhandled is None:\\n unhandled = []\\n\\n experiments = ExperimentList()\\n ## First try as image files\\n # experiments = ExperimentListFactory.from_datablock(\\n # DataBlockFactory.from_args(args, verbose, unhandled1))\\n\\n # Try to load from serialized formats\\n for filename in args:\\n try:\\n experiments.extend(\\n ExperimentListFactory.from_serialized_format(filename)\\n )\\n if verbose:\\n print(\\\"Loaded experiments from %s\\\" % filename)\\n except Exception as e:\\n if verbose:\\n print(\\\"Could not load experiments from %s: %s\\\" % (filename, str(e)))\\n unhandled.append(filename)\\n\\n # Return the experiments\\n return experiments\",\n \"def infile_list(args):\\n infiles = []\\n for arg in args:\\n infiles += glob.glob(arg)\\n infiles = [pipes.quote(f) for f in infiles]\\n return infiles\",\n \"def readFromFiles(self, networkFile, demandFile):\\n self.readNetworkFile(networkFile)\\n self.readDemandFile(demandFile)\\n self.validate()\\n self.finalize()\",\n \"def test_file_reader(self) -> None:\\n result = [['123', 'Jin He', 'Computer Science'],\\n ['234', 'Nanda Koka', 'Software Engineering'],\\n ['345', 'Benji Cai', 'Software Engineering']]\\n # file have header\\n self.assertTrue(\\n list(file_reader('C:/Users/Nidhi/Desktop/SEM3/810/HW08/student_majors.txt', 3, '|', True)) == result)\\n # file without header\\n self.assertFalse(\\n list(file_reader('C:/Users/Nidhi/Desktop/SEM3/810/HW08/student_majors.txt', 3, '|')) == result)\\n # More than 3 datafield\\n with self.assertRaises(ValueError):\\n list(file_reader(\\n 'C:/Users/Nidhi/Desktop/SEM3/810/HW08/student_majors.txt', 4, '|', True))\\n # file not found\\n with self.assertRaises(FileNotFoundError):\\n list(file_reader('abc.txt', 3, '|', True))\",\n \"def loadInputFiles(self):\\n\\t\\tfor filename in self.input_filename_list:\\n\\t\\t\\tfor module in self.modules:\\n\\t\\t\\t\\tmodule.Add(filename)\",\n \"def model_files(cmd_args):\\n if cmd_args.learning_file_list:\\n learning_files_list = files_constructor(cmd_args, file_type='learning')\\n else:\\n learning_files_list = None\\n\\n if cmd_args.prediction_file:\\n prediction_file = files_constructor(cmd_args, file_type='prediction')\\n else:\\n prediction_file = None\\n\\n\\n return learning_files_list, prediction_file\",\n \"def load_runner(flist, **kwargs):\\n if isinstance(flist, str):\\n flist = [flist]\\n frame_list = []\\n for fname in flist:\\n frame_list += _gen_frame_list(fname)\\n return _frame_loader(frame_list, **kwargs)\",\n \"def getFileList(*args, filespec: AnyStr=\\\"\\\", folder: AnyStr=\\\"\\\", **kwargs)->List[AnyStr]:\\n pass\",\n \"def read_file(inp_fn):\\n lines = [line.strip().split(\\\",\\\")\\n for line in open(inp_fn)\\n if not (line.startswith(\\\"#\\\"))]\\n return [(int(line[0]), year_record({\\\"male\\\": int(line[-3]),\\n \\\"female\\\": int(line[-2]),\\n \\\"unknown\\\": int(line[-1])},\\n None, None))\\n for line in lines[1:]]\",\n \"def get_file_data(reader_file):\\n\\n complete_data_list = []\\n for row in reader_file:\\n complete_data_list.append(row)\\n\\n return complete_data_list\",\n \"def select_files(input_line):\\n uri = str(input_line.split(',')[0])\\n label = str(input_line.split(',')[1])\\n\\n yield uri, label\",\n \"def ReadFilesGenerator(self):\\n\\n for file in self._file_names:\\n file_list = []\\n\\n # TODO see further into yielding one line at a time\\n with open(file, 'r', encoding='mbcs') as sped:\\n file_list = sped.read().splitlines()\\n\\n if not self.isSigned(file_list):\\n file_list = self.stripSignature(file_list)\\n\\n yield file, file_list\",\n \"def Open(self):\\n fileHandler = open(self.path, \\\"r\\\")\\n self.list = []\\n constructor = None\\n if self.format == \\\"music\\\": # Escoger el constructor adecuado\\n constructor = Format.Music\\n elif self.format == \\\"videos\\\":\\n constructor = Format.Videos\\n elif self.format == \\\"pictures\\\":\\n constructor = Format.Pictures\\n\\n for line in fileHandler:\\n name, author, album, year, _type, path = line.strip().split(\\\"¬\\\")\\n entry = constructor(name, author, album, year, _type, path)\\n self.list.append(entry)\\n\\n self.length = len(self.list)\\n fileHandler.close()\",\n \"def _generate_examples(self, **kwargs):\\n file_paths = kwargs.get(\\\"file_paths\\\")\\n if not file_paths:\\n raise ValueError(\\\"Must pass file_paths.\\\")\\n\\n for file_path in file_paths:\\n for record in SeqIO.parse(file_path, \\\"fasta\\\"):\\n yield record.id, {\\n \\\"sequence\\\": str(record.seq),\\n \\\"description\\\": str(record.description),\\n \\\"id\\\": str(record.id),\\n }\",\n \"def in_filepath_list(class_paths: List[str]) -> List:\\n registry, not_founds = build_registry(class_paths)\\n builder = FilepathListBuilder()\\n source = builder.build(registry)\\n\\n return [source, not_founds]\",\n \"def prepare_reader(self, filename_queue, batch_size=1024):\\n reader = tf.TFRecordReader()\\n _, serialized_examples = reader.read_up_to(filename_queue, batch_size)\\n\\n tf.add_to_collection(\\\"serialized_examples\\\", serialized_examples)\\n return self.prepare_serialized_examples(serialized_examples)\",\n \"def create_file_list(params):\\n data_dir = params.get('data_dir', '')\\n params['file_list'] = \\\".tmp.txt\\\"\\n imgtype_list = {'jpg', 'bmp', 'png', 'jpeg', 'rgb', 'tif', 'tiff'}\\n with open(params['file_list'], \\\"w\\\") as fout:\\n tmp_file_list = os.listdir(data_dir)\\n for file_name in tmp_file_list:\\n file_path = os.path.join(data_dir, file_name)\\n if imghdr.what(file_path) not in imgtype_list:\\n continue\\n fout.write(file_name + \\\" 0\\\" + \\\"\\\\n\\\")\",\n \"def read_lists(path_to_lists, taille,taille_sup):\\n\\n os.chdir(path_to_lists)\\n\\n heme = [i.strip() for i in open(\\\"heme.list\\\").readlines()]\\n heme_sample = data_sample(heme,taille_sup)\\n\\n steroid = [i.strip() for i in open(\\\"steroid.list\\\").readlines()]\\n steroid_sample = data_sample(steroid,len(steroid))\\n\\n nucleotide = [i.strip() for i in open(\\\"nucleotide.list\\\").readlines()]\\n nucleotide_sample = data_sample(nucleotide,taille)\\n\\n control = [i.strip() for i in open(\\\"control.list\\\").readlines()]\\n control_sample = data_sample(control,taille)\\n\\n #data_total = heme_sample+nucleotide_sample+control_sample+steroid_sample\\n\\n data_total = heme_sample+nucleotide_sample+control_sample\\n return data_total,heme,steroid,nucleotide,control\",\n \"def __init__(self, dataset_dir, listfile=None):\\n Reader.__init__(self, dataset_dir, listfile)\\n self._data = [line.split(',') for line in self._data]\\n self._data = [(x, float(t), int(y)) for (x, t, y) in self._data]\",\n \"def set_files(self, file_list):\\n\\tif file_list==None: return []\\n\\timport types\\n\\tisString = isinstance(file_list, types.StringTypes) \\n\\tisList = isinstance(file_list, list) \\n\\tassert isString or isList, \\\"You should provide a list of files as list or as CVS string!\\\"\\n\\tif isList: return file_list\\n\\tif isString :\\n\\t import re\\n\\t file_list_converted = re.sub(r'\\\\s', '', file_list).split(',') #remove all whitespaces\\n\\t return file_list_converted\",\n \"def defineFILEandRANK(files: int, ranks: int) -> Tuple[List[str]]:\\r\\n alpha = 'abcdefghijklmnopqrstuvwxyz'\\r\\n fileList = []\\r\\n rankList = []\\r\\n for file in range(files):\\r\\n fileList.append(alpha[file])\\r\\n for rank in reversed(range(0, ranks)):\\r\\n rankList.append(str(rank))\\r\\n \\r\\n return fileList, rankList\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6492544","0.63382894","0.6250799","0.611366","0.6069598","0.6018633","0.59182394","0.5909983","0.58632267","0.58579755","0.5853619","0.5849561","0.5829838","0.580928","0.57897955","0.5785899","0.57765526","0.57752377","0.57527864","0.57526433","0.5749772","0.5746242","0.5745427","0.5736978","0.5735016","0.5718842","0.57107687","0.56734157","0.5665857","0.5665557","0.56596106","0.5653231","0.56495225","0.56368935","0.56358653","0.56309664","0.56259525","0.56200933","0.56123054","0.5607947","0.55790967","0.5571911","0.55709785","0.5569839","0.5566333","0.5563507","0.55588645","0.55582106","0.55541813","0.55524856","0.55445844","0.55438435","0.55418944","0.55329305","0.5529695","0.5527274","0.551793","0.5510912","0.5508778","0.550814","0.5500842","0.5495455","0.5493571","0.54744893","0.5474127","0.54555285","0.5440225","0.54315084","0.54303676","0.542959","0.5418596","0.5416025","0.5415067","0.54094183","0.54074836","0.54039866","0.539313","0.5388496","0.53869545","0.53866214","0.5381011","0.537989","0.5379454","0.53788984","0.53745127","0.53741","0.5368982","0.5366444","0.53659916","0.5358723","0.53579015","0.5355051","0.5344213","0.53426135","0.53375554","0.53335905","0.5324907","0.5321942","0.5321128","0.5316644"],"string":"[\n \"0.6492544\",\n \"0.63382894\",\n \"0.6250799\",\n \"0.611366\",\n \"0.6069598\",\n \"0.6018633\",\n \"0.59182394\",\n \"0.5909983\",\n \"0.58632267\",\n \"0.58579755\",\n \"0.5853619\",\n \"0.5849561\",\n \"0.5829838\",\n \"0.580928\",\n \"0.57897955\",\n \"0.5785899\",\n \"0.57765526\",\n \"0.57752377\",\n \"0.57527864\",\n \"0.57526433\",\n \"0.5749772\",\n \"0.5746242\",\n \"0.5745427\",\n \"0.5736978\",\n \"0.5735016\",\n \"0.5718842\",\n \"0.57107687\",\n \"0.56734157\",\n \"0.5665857\",\n \"0.5665557\",\n \"0.56596106\",\n \"0.5653231\",\n \"0.56495225\",\n \"0.56368935\",\n \"0.56358653\",\n \"0.56309664\",\n \"0.56259525\",\n \"0.56200933\",\n \"0.56123054\",\n \"0.5607947\",\n \"0.55790967\",\n \"0.5571911\",\n \"0.55709785\",\n \"0.5569839\",\n \"0.5566333\",\n \"0.5563507\",\n \"0.55588645\",\n \"0.55582106\",\n \"0.55541813\",\n \"0.55524856\",\n \"0.55445844\",\n \"0.55438435\",\n \"0.55418944\",\n \"0.55329305\",\n \"0.5529695\",\n \"0.5527274\",\n \"0.551793\",\n \"0.5510912\",\n \"0.5508778\",\n \"0.550814\",\n \"0.5500842\",\n \"0.5495455\",\n \"0.5493571\",\n \"0.54744893\",\n \"0.5474127\",\n \"0.54555285\",\n \"0.5440225\",\n \"0.54315084\",\n \"0.54303676\",\n \"0.542959\",\n \"0.5418596\",\n \"0.5416025\",\n \"0.5415067\",\n \"0.54094183\",\n \"0.54074836\",\n \"0.54039866\",\n \"0.539313\",\n \"0.5388496\",\n \"0.53869545\",\n \"0.53866214\",\n \"0.5381011\",\n \"0.537989\",\n \"0.5379454\",\n \"0.53788984\",\n \"0.53745127\",\n \"0.53741\",\n \"0.5368982\",\n \"0.5366444\",\n \"0.53659916\",\n \"0.5358723\",\n \"0.53579015\",\n \"0.5355051\",\n \"0.5344213\",\n \"0.53426135\",\n \"0.53375554\",\n \"0.53335905\",\n \"0.5324907\",\n \"0.5321942\",\n \"0.5321128\",\n \"0.5316644\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.679022"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94986,"cells":{"query":{"kind":"string","value":"return the number of slices per timepoint"},"document":{"kind":"string","value":"def getSlicesPerTimepoint(self):\n\t\treturn self.slicesPerTimepoint"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getDataSetCount(self):\n\t\treturn int(self.numberOfImages / self.slicesPerTimepoint)","def size(self):\n size = 1\n for current_slice in self.slices:\n size *= current_slice.stop - current_slice.start\n return size","def n(self):\n return self._time_axis.size","def _get_slice_len(s, axlen):\n if s.start is None:\n start = 0\n else:\n start = s.start\n if s.stop is None:\n stop = axlen\n else:\n stop = np.min([s.stop, axlen])\n if s.step is None:\n step = 1\n else:\n step = s.step\n\n return ((stop - 1 - start) // step) + 1","def getDimensions(self):\n\t\tprint \"Returning\",self.x,self.y,self.slicesPerTimepoint\n\t\treturn (self.x, self.y, self.slicesPerTimepoint)","def size(self, time):\n if self.start_time <= time <= self.end_time:\n return self.masks[time - self.start_time].sum()\n else:\n return 0","def n_timesteps(self) -> int:\n return len(self.time)","def spike_count(spikeTime, start, stop, dt):\n\n\n #Spike time turned into a numpy array\n spikeTime = np.array(spikeTime)\n # print('Spike Times: ', spikeTime)\n\n #Creat interval array - intervals in which to break up the time array - sub time interval array\n duration = stop-start #Total run time\n n = duration/dt #How many subintervals from time horizon results from user defined interval\n splitInterval = np.linspace(0, duration, n+1) #create numpy array of subinterval over which to count spikes\n # print ('split interval: ', splitInterval)\n\n ##Find length over which to iterate in for loop\n length_splitInt = len(splitInterval)\n # print('length splitInterval: ', length_splitInt)\n length_time = len(spikeTime)\n # print('length time: ', length_time)\n length = length_splitInt + ((length_time) - 2)\n # print('length :', length)\n\n i=0 #inex for time array\n j=0 #index for splitInterval array.\n k=0 #index for new matrix that will store the grouped values from the split time array\n counter = 0 #counter variable to keep track of spike count for each subinterval through loop\n SpikeCount = [] #Initialize array to collect the number of spikes occuring wihtin each subinterval\n\n for i in range(length):\n if (i == 0) and (spikeTime[0] == splitInterval[0]):\n counter += 1\n i += 1\n\n # Spot check\n # print('if counter: ', counter)\n # print('time element: ', spikeTime[k])\n # print('splitInt: ', splitInterval[j], splitInterval[j + 1])\n # print('i: ', i)\n # print('if k: ', k)\n\n if k < (len(spikeTime) - 1):\n k += 1\n\n # Spot check\n # print('iff k: ', k)\n # print('iff counter: ', counter)\n\n else:\n j += 1\n\n # Spot check\n # print('iff counter: ', counter)\n # print(SpikeCount)\n # print('iff j: ', j)\n\n elif (spikeTime[k] > splitInterval[j]) and (spikeTime[k] <= splitInterval[j + 1]):\n counter += 1\n i += 1\n\n # Spot check\n # print('if counter: ', counter)\n # print('time element: ', spikeTime[k])\n # print('splitInt: ', splitInterval[j], splitInterval[j + 1])\n # print('i: ', i)\n # print('if k: ', k)\n\n if k < (len(spikeTime) - 1):\n k += 1\n\n # Spot check\n # print('iff k: ', k)\n # print('iff counter: ', counter)\n\n else:\n j += 1\n # Spot check\n SpikeCount.append(counter)\n # print('iff counter: ', counter)\n # print(SpikeCount)\n # print('iff j: ', j)\n\n\n\n else:\n SpikeCount.append(counter)\n counter = 0\n j += 1\n i += 1\n\n # Spot Check\n # print('else counter: ', counter)\n # print(SpikeCount)\n # print('time element: ', spikeTime[k])\n # print('splitInt: ', splitInterval[j], splitInterval[j + 1])\n # print('else j: ', j)\n # print('else i: ', i)\n # print('else k: ', k)\n\n return (SpikeCount, splitInterval)","def calc_cycle_count(self, time):\n dur = self.get_duration()\n phases = time / dur\n count = int(math.floor(phases))\n\n if not self.enable_loop():\n count = np.clip(count, 0, 1)\n\n return count","def times(self) -> int:\n return self._channel_arrays[0].shape[self.time_pos]","def numel(self):\n return self.t.size","def count_timepoints(sc, session, files):\n tuples = zip(range(len(files)), files)\n files_sc = sc.parallelize(tuples)\n\n def count_planes(kv):\n index, path2 = kv\n try:\n from ScanImageTiffReader import ScanImageTiffReader\n img = ScanImageTiffReader(path2).data()\n except Exception:\n import tifffile\n img = tifffile.imread(path2)\n return img.shape[0]\n\n data2 = files_sc.map(count_planes).collect()\n frame_numbers = np.array(data2)\n vol_numbers = frame_numbers / len(session.fieldMask)\n return vol_numbers.astype(int)","def get_num_timesteps(self) -> int:\n return len(self._indices)","def setSlicesPerTimepoint(self, n):\n\t\tassert n > 0, \"Slices per timepoint needs to be greater than 0\"\n\t\tprint \"Setting slices per timepoint to \", n\n\t\tself.slicesPerTimepoint = n\n\t\tself.z = n\n\t\tself.readers = []","def count_segments(markers) -> int:\n cnt = Counter()\n for row in markers:\n cnt.update(row)\n n_cnt = dict(takewhile(lambda x: x[1] >= 10, cnt.most_common()))\n del n_cnt[1]\n del n_cnt[-1]\n return len(n_cnt.keys())","def getSegmentCount(self) -> int:\n ...","def _number_of_intervals(self):\n return self._number_of_levels - 1","def ntimebins(self, t0, t1):\n t0 = Time(t0, scale='utc')\n t1 = Time(t1, scale='utc')\n nt = ((t1-t0).to(u.s) / self.dtsample /\n (self.setsize)).to(u.dimensionless_unscaled).value\n return np.round(nt).astype(int)","def count(time):\n \n return len(events(time))","def _calc_slices(X):\n\n n_rows = X.shape[0]\n slices = [n_rows // comm.size for _ in range(comm.size)]\n count = n_rows % comm.size\n for i in range(count):\n slices[i] += 1\n\n return np.array(slices, dtype=np.int64)","def N(self):\n return len(self.time)","def traj_nslice (u,teq,tsample) :\n # get the number of frames in the slice (http://stackoverflow.com/a/7223557)\n traj_slice = u.trajectory[teq::tsample]\n return sum(1 for _ in traj_slice)","def traj_nslice (u,teq,tsample) :\n # get the number of frames in the slice (http://stackoverflow.com/a/7223557)\n traj_slice = u.trajectory[teq::tsample]\n return sum(1 for _ in traj_slice)","def slice_timeseries(n_slices,dataset):\n\n n,l=np.shape(dataset)\n\n X = np.reshape(dataset,(n*n_slices,l//n_slices))\n\n print('sliced data shape (nr. of slices, slice length):',np.shape(X))\n print('#####################################')\n \n return X","def get_num_chunks(self) -> int:","def __len__(self):\n _, timesteps, height, width = self.data.shape\n height //= self.size\n width //= self.size\n\n if self.subset == 'train':\n out = self.length\n elif self.subset == 'all':\n out = height * width\n else:\n out = (height // 2) * (width // 2)\n\n if not self.time:\n out *= timesteps\n\n return out","def dim_calculator():\r\n probe_set = np.arange(1, 101)\r\n X = -36 + ((probe_set - 1) // 10) * 4\r\n Y = 2 - ((probe_set - 1) % 10) * 4\r\n dim = np.vstack((X, Y)).T\r\n return dim","def dim(self) -> int:","def n_points(self):\n\n if self.data_reduced:\n return len(self.data_reduced[0])\n else:\n return 0","def Test_NumSegments(Daten):\n N_Leitungen = len(Daten.PipeSegments)\n\n return N_Leitungen","def get_naive_size(self) -> int:\n return (self.triples.time_end - self.triples.time_begin + 1).sum()","def voxel_count(self):\n return self.cols * self.rows * self.sections","def n_elements(x, dist, var=None):\n n = dist/mdiff(x)\n if var == 'time':\n n = n/60\n return int(np.round(n))","def num_time_bins(self):\n return self.header.time_gate_bin_count * self.header.samples_per_time_bin","def slice_length(start, stop, step):\n return (stop - start + step - 1) // step","def multiListSliceCount(lol):\n count = 1\n for i in range(0, len(lol)):\n count *= len(lol[i])\n #print \"multiListSliceCount of:%s is:%d\" % (lol, count)\n return count","def get_number_of_measurement(self):\n num_of_meas = 0\n for time in self.mdvtc.keys():\n num_of_meas = num_of_meas + self.mdvtc[time].get_number_of_measurement()\n #\n return num_of_meas","def calc_num_bursts(num_timeseries):\n num_vectors = 0\n for i in range(1, num_timeseries + 1):\n num_vectors += ((i + (CORRELATION_NUM_PIPES - 1)) /\n CORRELATION_NUM_PIPES)\n return ((num_vectors + (CORRELATION_NUM_VECTORS_PER_BURST-1)) /\n CORRELATION_NUM_VECTORS_PER_BURST)","def get_series_data_length(self):\n global OVER_PAD_LENGTH_COUNT\n\n length = []\n for k in range(3):\n for i in range(len(self.pulse_data[k])):\n length.append(self.pulse_data[k][i].shape[0])\n return length","def n_elements(self) -> int:\n n_elem = np.prod(self.shape)\n if self.n_timesteps > 1:\n n_elem = int(n_elem / self.n_timesteps)\n return n_elem","def compute_num_tracks(x_offset: int, y_offset: int,\n x: int, y: int, track_info: Dict[int, int]):\n x_diff = x - x_offset\n y_diff = y - y_offset\n result = 0\n for length, num_track in track_info.items():\n if x_diff % length == 0 and y_diff % length == 0:\n # it's the tile\n result += num_track\n return result","def __len__(self) -> int:\n import h5py\n\n with h5py.File(\n os.path.join(self.root, self.data_dir, self.img_file_name), \"r\"\n ) as f:\n num_datapoints: int = f[self.split][\"pv_log\"].shape[0]\n\n return num_datapoints","def num_ticks(self, start, end, desired_ticks=8):\n return len(self.ticks(start, end, desired_ticks))","def num_ticks(self, start, end, desired_ticks=8):\n return len(self.ticks(start, end, desired_ticks))","def num_ticks(self, start, end, desired_ticks=8):\n return len(self.ticks(start, end, desired_ticks))","def count_elements_in_dataset(dataset):\n return dataset.count()","def nSlices(self):\n return self._c_param.lee_richards_n_slices","def countComponents26(cube):\n n,l = labelComponents26(cube);\n return n;","def get_event_count(event_times, start, end):\n mask = (event_times > start) & (event_times <= end)\n return event_times[mask].size","def get_time_slices(self):\n tot = []\n for clu in self._clusters:\n tot.extend(self._clusters[clu].to_dict()[:])\n #tot.sort()\n return tot","def segment_n(self):\n return len(self.segment_lengths)","def Points_Counting(self):\n return len(self.__traectory_list)","def __CalculateSliceSize(self, readShapeZYX):\n # readShapeZYX is the dimension of the data we must READ to fill the required output area;\n # i.e .the fill area plus margins. If we're filling globally it's the same thing.\n dataBPP = 4\n memLimit = self._jobDetails.MemTargetBytes\n outputsBPP = dataBPP * 2 + 1 # the output data, distances, and flags\n # approximate total number of pixels we can read for each file\n sliceSqrd = memLimit / (readShapeZYX[0] * (dataBPP + outputsBPP))\n # not implementing slicing in y dimension so xSize is total pixels / total height\n sliceXSize = sliceSqrd / readShapeZYX[1]\n return sliceXSize","def n_series(self):\n return self.container['n_series']","def _num_samples(x: npt.ArrayLike) -> int:\n if not hasattr(x, \"__len__\") and not hasattr(x, \"shape\"):\n if hasattr(x, \"__array__\"):\n x = np.asarray(x)\n else:\n raise TypeError(\"Expected sequence or array-like, got %s\" % type(x))\n if hasattr(x, \"shape\"):\n if len(x.shape) == 0:\n raise TypeError(\"Singleton array %r cannot be considered\" \" a valid collection.\" % x)\n # Check that shape is returning an integer or default to len\n # Dask dataframes may not return numeric shape[0] value\n if isinstance(x.shape[0], numbers.Integral):\n return x.shape[0]\n else:\n return len(x)\n else:\n return len(x)","def get_nb_element_per_dimension(recipe):\n return len(recipe[\"r\"]), len(recipe[\"c\"]), len(recipe[\"z\"])","def __number_measurements(a, func_axis=None):\n if func_axis == None:\n return a.size\n else:\n return a.size / a.shape[func_axis]","def countTriplets(arr, r):\n c_2, c_3 = Counter(), Counter()\n n_triplets = 0\n for e in arr:\n # print(f'arr: {arr}, e: {e}, c_3: {c_3}, c_2: {c_2}, n_triplets: {n_triplets}')\n if e in c_3:\n n_triplets += c_3[e]\n if e in c_2:\n c_3[e*r] += c_2[e]\n c_2[e*r] += 1\n return n_triplets","def dim_calculatorP3():\r\n probe_set = np.arange(1, 101)\r\n X = 20 - 36 + ((probe_set - 1) // 10) * 4\r\n Y = 2 - ((probe_set - 1) % 10) * 4\r\n dim = np.vstack((X, Y)).T\r\n return dim","def num_points_sweep(self, start, stop, step):\r\n return(abs((stop - start)//step) + 1)","def get_length(data):\n return np.array([len(conv) for conv in data]).reshape(-1, 1)","def count_data(self):\n try:\n ndata = len(self.x)\n logger.info(\"Number of data points: {0}\".format(ndata))\n except AttributeError:\n logger.error(\"Data object has not been defined\")\n ndata = 0\n return ndata","def get_contours_number(self):\n ncontour = len(self.x)\n logger.info(\"Number of contours: {0}\".format(ncontour))\n return ncontour","def getNumTiles(self):\n return len(list(product(list(range(self.width+1))[1:], list(range(self.height+1))[1:])))","def get_number_of_measurement(self):\n used_fragments = set()\n counter = 0\n for fragment in self.observed_fragments:\n num_of_isotope = 0\n used_counter = 0\n for i in self.mdv[fragment]:\n num_of_isotope = num_of_isotope + 1\n if self.mdv[fragment][i]['use'] == 'use':\n\n counter = counter + 1\n used_counter = used_counter + 1\n if num_of_isotope == used_counter:\n used_fragments.add(fragment)\n return counter-len(used_fragments)","def __len__(self):\n nsamp = self.data.shape[-1]\n kernel = int(self.kernel * self.fs)\n stride = int(self.stride * self.fs)\n n_stride = int(np.ceil((nsamp - kernel) / stride) + 1)\n return max(0, n_stride)","def compute_track_length(points, bin_size=17):\n pca = PCA(n_components=2)\n length = 0.\n if len(points) >= 2:\n coords_pca = pca.fit_transform(points)[:, 0]\n bins = np.arange(coords_pca.min(), coords_pca.max(), bin_size)\n # bin_inds takes values in [1, len(bins)]\n bin_inds = np.digitize(coords_pca, bins)\n for b_i in np.unique(bin_inds):\n mask = bin_inds == b_i\n if np.count_nonzero(mask) < 2: continue\n # Repeat PCA locally for better measurement of dx\n # pca_axis = pca.fit_transform(points[mask])\n pca_axis = coords_pca[mask]\n dx = pca_axis.max() - pca_axis.min()\n length += dx\n return length","def nr_points(self):\n return len(self.x)","def count(self) -> int:\n return self.end_measure_num - self.start_measure_num + 1","def n_rounds(self) -> int:\n return self.y.shape[0]","def num_chunking_units(self):\n if self._source_paths:\n return len(self._source_paths)\n return 1","def n_cs(self):\n return np.size(self._cs, 0)","def _get_observation_count(self):\n observation_count = 0\n for sequence in self.seq_list:\n observation_count += sequence.shape[0] \n \n return observation_count","def count(self):\r\n return self.data_array.size","def get_points_number(self):\n ncontour = self.get_contours_number\n npoints = []\n for i in range(0, ncontour):\n npoints.append(len(self.x[i]))\n return npoints","def __len__(self):\n return int(np.floor(len(self.dataset_df) / self.batch_size))","def numSegments(self):\n\n return self.getHierView().numSegments()","def get_stepsize(ds):\n tube_pos = ds.axes[-1]\n if tube_pos.ndim == 2: #very old data, just take one slice\n tube_pos = tube_pos[0]\n tubesep = abs(tube_pos[0]-tube_pos[-1])/(len(tube_pos)-1)\n tube_steps = ds.axes[0]\n bin_size = abs(tube_steps[0]-tube_steps[-1])/(len(tube_steps)-1)\n pixel_step = int(round(tubesep/bin_size))\n bin_size = tubesep/pixel_step\n #print 'Determined tube separation to be %f, corresponding to %d steps' % (tubesep,pixel_step)\n return bin_size","def get_num_points(self):\n dimensions = self.data.shape\n return dimensions[0]","def dimension(self):","def get_number_of_segments(self):\n\n return len(self._break_points) - 1","def dimensions():","def calculate_number_of_segments(self):\n return sum(len(eg.transcript_file.segments) for eg in self.exemplars)","def count_segments(self, raw_only: bool = False) -> int:\n if self.segments:\n self_count = 0 if raw_only else 1\n return self_count + sum(\n seg.count_segments(raw_only=raw_only) for seg in self.segments\n )\n else:\n return 1","def dim(self) -> int:\n pass","def number_of_steps(self) -> int:\n return len(self.step_points)","def num_timesteps(self):\n return self._num_timesteps","def nbytes_at(self, device_id:int):\n if self._slices:\n if isinstance(self._coherence._local_states[device_id], dict): # there are subarrays no this device\n if self._slices_hash in self._coherence._local_states[device_id].keys(): # this subarray is already there\n return self._array.nbytes_at(device_id)\n else: # the subarray will be moved to there\n return self._array.nbytes_at(device_id) + self.subarray_nbytes # add the incoming subarray size\n else: # there is a complete copy on this device, no need to prepare subarray\n return self.nbytes\n else:\n return self.nbytes","def count():","def n_points(self) -> int:\n return len(self.all_df)","def __len__(self): \r\n length = len(self.data) - 2* self.skip_window\r\n #print ('length', length)\r\n return length\r\n #raise NotImplementedError('Implement the __len__ method of the dataset')\r","def n_points(self) -> int:\n return len(self.df)","def size(self) -> Tuple[groupable, pdarray]:\n return self.count()","def num_run_cycles(self, run_idx):\n return self.num_traj_frames(run_idx, 0)","def numberOfPoints(self):\n return 20000","def getLength(self):\n lons = self._toplons\n lats = self._toplats\n seg = self._group_index\n groups = np.unique(seg)\n ng = len(groups)\n rlength = 0\n for i in range(ng):\n group_segments = np.where(groups[i] == seg)[0]\n nseg = len(group_segments) - 1\n for j in range(nseg):\n ind = group_segments[j]\n P0 = Point(lons[ind], lats[ind])\n P1 = Point(lons[ind + 1], lats[ind + 1])\n dist = P0.distance(P1)\n rlength = rlength + dist\n return rlength","def get_dimension_length(self):\n pass","def find_num_beats_per_window(p1, p2, p3, p4, p5, p6):\n\n return len(p1), len(p2), len(p3), len(p4), len(p5), len(p6)","def __len__(self):\r\n return int(np.ceil(len(self.pathways) / float(self.batch_size)))","def _get_observation_dimension(self):\n return len(self._get_observation_np())"],"string":"[\n \"def getDataSetCount(self):\\n\\t\\treturn int(self.numberOfImages / self.slicesPerTimepoint)\",\n \"def size(self):\\n size = 1\\n for current_slice in self.slices:\\n size *= current_slice.stop - current_slice.start\\n return size\",\n \"def n(self):\\n return self._time_axis.size\",\n \"def _get_slice_len(s, axlen):\\n if s.start is None:\\n start = 0\\n else:\\n start = s.start\\n if s.stop is None:\\n stop = axlen\\n else:\\n stop = np.min([s.stop, axlen])\\n if s.step is None:\\n step = 1\\n else:\\n step = s.step\\n\\n return ((stop - 1 - start) // step) + 1\",\n \"def getDimensions(self):\\n\\t\\tprint \\\"Returning\\\",self.x,self.y,self.slicesPerTimepoint\\n\\t\\treturn (self.x, self.y, self.slicesPerTimepoint)\",\n \"def size(self, time):\\n if self.start_time <= time <= self.end_time:\\n return self.masks[time - self.start_time].sum()\\n else:\\n return 0\",\n \"def n_timesteps(self) -> int:\\n return len(self.time)\",\n \"def spike_count(spikeTime, start, stop, dt):\\n\\n\\n #Spike time turned into a numpy array\\n spikeTime = np.array(spikeTime)\\n # print('Spike Times: ', spikeTime)\\n\\n #Creat interval array - intervals in which to break up the time array - sub time interval array\\n duration = stop-start #Total run time\\n n = duration/dt #How many subintervals from time horizon results from user defined interval\\n splitInterval = np.linspace(0, duration, n+1) #create numpy array of subinterval over which to count spikes\\n # print ('split interval: ', splitInterval)\\n\\n ##Find length over which to iterate in for loop\\n length_splitInt = len(splitInterval)\\n # print('length splitInterval: ', length_splitInt)\\n length_time = len(spikeTime)\\n # print('length time: ', length_time)\\n length = length_splitInt + ((length_time) - 2)\\n # print('length :', length)\\n\\n i=0 #inex for time array\\n j=0 #index for splitInterval array.\\n k=0 #index for new matrix that will store the grouped values from the split time array\\n counter = 0 #counter variable to keep track of spike count for each subinterval through loop\\n SpikeCount = [] #Initialize array to collect the number of spikes occuring wihtin each subinterval\\n\\n for i in range(length):\\n if (i == 0) and (spikeTime[0] == splitInterval[0]):\\n counter += 1\\n i += 1\\n\\n # Spot check\\n # print('if counter: ', counter)\\n # print('time element: ', spikeTime[k])\\n # print('splitInt: ', splitInterval[j], splitInterval[j + 1])\\n # print('i: ', i)\\n # print('if k: ', k)\\n\\n if k < (len(spikeTime) - 1):\\n k += 1\\n\\n # Spot check\\n # print('iff k: ', k)\\n # print('iff counter: ', counter)\\n\\n else:\\n j += 1\\n\\n # Spot check\\n # print('iff counter: ', counter)\\n # print(SpikeCount)\\n # print('iff j: ', j)\\n\\n elif (spikeTime[k] > splitInterval[j]) and (spikeTime[k] <= splitInterval[j + 1]):\\n counter += 1\\n i += 1\\n\\n # Spot check\\n # print('if counter: ', counter)\\n # print('time element: ', spikeTime[k])\\n # print('splitInt: ', splitInterval[j], splitInterval[j + 1])\\n # print('i: ', i)\\n # print('if k: ', k)\\n\\n if k < (len(spikeTime) - 1):\\n k += 1\\n\\n # Spot check\\n # print('iff k: ', k)\\n # print('iff counter: ', counter)\\n\\n else:\\n j += 1\\n # Spot check\\n SpikeCount.append(counter)\\n # print('iff counter: ', counter)\\n # print(SpikeCount)\\n # print('iff j: ', j)\\n\\n\\n\\n else:\\n SpikeCount.append(counter)\\n counter = 0\\n j += 1\\n i += 1\\n\\n # Spot Check\\n # print('else counter: ', counter)\\n # print(SpikeCount)\\n # print('time element: ', spikeTime[k])\\n # print('splitInt: ', splitInterval[j], splitInterval[j + 1])\\n # print('else j: ', j)\\n # print('else i: ', i)\\n # print('else k: ', k)\\n\\n return (SpikeCount, splitInterval)\",\n \"def calc_cycle_count(self, time):\\n dur = self.get_duration()\\n phases = time / dur\\n count = int(math.floor(phases))\\n\\n if not self.enable_loop():\\n count = np.clip(count, 0, 1)\\n\\n return count\",\n \"def times(self) -> int:\\n return self._channel_arrays[0].shape[self.time_pos]\",\n \"def numel(self):\\n return self.t.size\",\n \"def count_timepoints(sc, session, files):\\n tuples = zip(range(len(files)), files)\\n files_sc = sc.parallelize(tuples)\\n\\n def count_planes(kv):\\n index, path2 = kv\\n try:\\n from ScanImageTiffReader import ScanImageTiffReader\\n img = ScanImageTiffReader(path2).data()\\n except Exception:\\n import tifffile\\n img = tifffile.imread(path2)\\n return img.shape[0]\\n\\n data2 = files_sc.map(count_planes).collect()\\n frame_numbers = np.array(data2)\\n vol_numbers = frame_numbers / len(session.fieldMask)\\n return vol_numbers.astype(int)\",\n \"def get_num_timesteps(self) -> int:\\n return len(self._indices)\",\n \"def setSlicesPerTimepoint(self, n):\\n\\t\\tassert n > 0, \\\"Slices per timepoint needs to be greater than 0\\\"\\n\\t\\tprint \\\"Setting slices per timepoint to \\\", n\\n\\t\\tself.slicesPerTimepoint = n\\n\\t\\tself.z = n\\n\\t\\tself.readers = []\",\n \"def count_segments(markers) -> int:\\n cnt = Counter()\\n for row in markers:\\n cnt.update(row)\\n n_cnt = dict(takewhile(lambda x: x[1] >= 10, cnt.most_common()))\\n del n_cnt[1]\\n del n_cnt[-1]\\n return len(n_cnt.keys())\",\n \"def getSegmentCount(self) -> int:\\n ...\",\n \"def _number_of_intervals(self):\\n return self._number_of_levels - 1\",\n \"def ntimebins(self, t0, t1):\\n t0 = Time(t0, scale='utc')\\n t1 = Time(t1, scale='utc')\\n nt = ((t1-t0).to(u.s) / self.dtsample /\\n (self.setsize)).to(u.dimensionless_unscaled).value\\n return np.round(nt).astype(int)\",\n \"def count(time):\\n \\n return len(events(time))\",\n \"def _calc_slices(X):\\n\\n n_rows = X.shape[0]\\n slices = [n_rows // comm.size for _ in range(comm.size)]\\n count = n_rows % comm.size\\n for i in range(count):\\n slices[i] += 1\\n\\n return np.array(slices, dtype=np.int64)\",\n \"def N(self):\\n return len(self.time)\",\n \"def traj_nslice (u,teq,tsample) :\\n # get the number of frames in the slice (http://stackoverflow.com/a/7223557)\\n traj_slice = u.trajectory[teq::tsample]\\n return sum(1 for _ in traj_slice)\",\n \"def traj_nslice (u,teq,tsample) :\\n # get the number of frames in the slice (http://stackoverflow.com/a/7223557)\\n traj_slice = u.trajectory[teq::tsample]\\n return sum(1 for _ in traj_slice)\",\n \"def slice_timeseries(n_slices,dataset):\\n\\n n,l=np.shape(dataset)\\n\\n X = np.reshape(dataset,(n*n_slices,l//n_slices))\\n\\n print('sliced data shape (nr. of slices, slice length):',np.shape(X))\\n print('#####################################')\\n \\n return X\",\n \"def get_num_chunks(self) -> int:\",\n \"def __len__(self):\\n _, timesteps, height, width = self.data.shape\\n height //= self.size\\n width //= self.size\\n\\n if self.subset == 'train':\\n out = self.length\\n elif self.subset == 'all':\\n out = height * width\\n else:\\n out = (height // 2) * (width // 2)\\n\\n if not self.time:\\n out *= timesteps\\n\\n return out\",\n \"def dim_calculator():\\r\\n probe_set = np.arange(1, 101)\\r\\n X = -36 + ((probe_set - 1) // 10) * 4\\r\\n Y = 2 - ((probe_set - 1) % 10) * 4\\r\\n dim = np.vstack((X, Y)).T\\r\\n return dim\",\n \"def dim(self) -> int:\",\n \"def n_points(self):\\n\\n if self.data_reduced:\\n return len(self.data_reduced[0])\\n else:\\n return 0\",\n \"def Test_NumSegments(Daten):\\n N_Leitungen = len(Daten.PipeSegments)\\n\\n return N_Leitungen\",\n \"def get_naive_size(self) -> int:\\n return (self.triples.time_end - self.triples.time_begin + 1).sum()\",\n \"def voxel_count(self):\\n return self.cols * self.rows * self.sections\",\n \"def n_elements(x, dist, var=None):\\n n = dist/mdiff(x)\\n if var == 'time':\\n n = n/60\\n return int(np.round(n))\",\n \"def num_time_bins(self):\\n return self.header.time_gate_bin_count * self.header.samples_per_time_bin\",\n \"def slice_length(start, stop, step):\\n return (stop - start + step - 1) // step\",\n \"def multiListSliceCount(lol):\\n count = 1\\n for i in range(0, len(lol)):\\n count *= len(lol[i])\\n #print \\\"multiListSliceCount of:%s is:%d\\\" % (lol, count)\\n return count\",\n \"def get_number_of_measurement(self):\\n num_of_meas = 0\\n for time in self.mdvtc.keys():\\n num_of_meas = num_of_meas + self.mdvtc[time].get_number_of_measurement()\\n #\\n return num_of_meas\",\n \"def calc_num_bursts(num_timeseries):\\n num_vectors = 0\\n for i in range(1, num_timeseries + 1):\\n num_vectors += ((i + (CORRELATION_NUM_PIPES - 1)) /\\n CORRELATION_NUM_PIPES)\\n return ((num_vectors + (CORRELATION_NUM_VECTORS_PER_BURST-1)) /\\n CORRELATION_NUM_VECTORS_PER_BURST)\",\n \"def get_series_data_length(self):\\n global OVER_PAD_LENGTH_COUNT\\n\\n length = []\\n for k in range(3):\\n for i in range(len(self.pulse_data[k])):\\n length.append(self.pulse_data[k][i].shape[0])\\n return length\",\n \"def n_elements(self) -> int:\\n n_elem = np.prod(self.shape)\\n if self.n_timesteps > 1:\\n n_elem = int(n_elem / self.n_timesteps)\\n return n_elem\",\n \"def compute_num_tracks(x_offset: int, y_offset: int,\\n x: int, y: int, track_info: Dict[int, int]):\\n x_diff = x - x_offset\\n y_diff = y - y_offset\\n result = 0\\n for length, num_track in track_info.items():\\n if x_diff % length == 0 and y_diff % length == 0:\\n # it's the tile\\n result += num_track\\n return result\",\n \"def __len__(self) -> int:\\n import h5py\\n\\n with h5py.File(\\n os.path.join(self.root, self.data_dir, self.img_file_name), \\\"r\\\"\\n ) as f:\\n num_datapoints: int = f[self.split][\\\"pv_log\\\"].shape[0]\\n\\n return num_datapoints\",\n \"def num_ticks(self, start, end, desired_ticks=8):\\n return len(self.ticks(start, end, desired_ticks))\",\n \"def num_ticks(self, start, end, desired_ticks=8):\\n return len(self.ticks(start, end, desired_ticks))\",\n \"def num_ticks(self, start, end, desired_ticks=8):\\n return len(self.ticks(start, end, desired_ticks))\",\n \"def count_elements_in_dataset(dataset):\\n return dataset.count()\",\n \"def nSlices(self):\\n return self._c_param.lee_richards_n_slices\",\n \"def countComponents26(cube):\\n n,l = labelComponents26(cube);\\n return n;\",\n \"def get_event_count(event_times, start, end):\\n mask = (event_times > start) & (event_times <= end)\\n return event_times[mask].size\",\n \"def get_time_slices(self):\\n tot = []\\n for clu in self._clusters:\\n tot.extend(self._clusters[clu].to_dict()[:])\\n #tot.sort()\\n return tot\",\n \"def segment_n(self):\\n return len(self.segment_lengths)\",\n \"def Points_Counting(self):\\n return len(self.__traectory_list)\",\n \"def __CalculateSliceSize(self, readShapeZYX):\\n # readShapeZYX is the dimension of the data we must READ to fill the required output area;\\n # i.e .the fill area plus margins. If we're filling globally it's the same thing.\\n dataBPP = 4\\n memLimit = self._jobDetails.MemTargetBytes\\n outputsBPP = dataBPP * 2 + 1 # the output data, distances, and flags\\n # approximate total number of pixels we can read for each file\\n sliceSqrd = memLimit / (readShapeZYX[0] * (dataBPP + outputsBPP))\\n # not implementing slicing in y dimension so xSize is total pixels / total height\\n sliceXSize = sliceSqrd / readShapeZYX[1]\\n return sliceXSize\",\n \"def n_series(self):\\n return self.container['n_series']\",\n \"def _num_samples(x: npt.ArrayLike) -> int:\\n if not hasattr(x, \\\"__len__\\\") and not hasattr(x, \\\"shape\\\"):\\n if hasattr(x, \\\"__array__\\\"):\\n x = np.asarray(x)\\n else:\\n raise TypeError(\\\"Expected sequence or array-like, got %s\\\" % type(x))\\n if hasattr(x, \\\"shape\\\"):\\n if len(x.shape) == 0:\\n raise TypeError(\\\"Singleton array %r cannot be considered\\\" \\\" a valid collection.\\\" % x)\\n # Check that shape is returning an integer or default to len\\n # Dask dataframes may not return numeric shape[0] value\\n if isinstance(x.shape[0], numbers.Integral):\\n return x.shape[0]\\n else:\\n return len(x)\\n else:\\n return len(x)\",\n \"def get_nb_element_per_dimension(recipe):\\n return len(recipe[\\\"r\\\"]), len(recipe[\\\"c\\\"]), len(recipe[\\\"z\\\"])\",\n \"def __number_measurements(a, func_axis=None):\\n if func_axis == None:\\n return a.size\\n else:\\n return a.size / a.shape[func_axis]\",\n \"def countTriplets(arr, r):\\n c_2, c_3 = Counter(), Counter()\\n n_triplets = 0\\n for e in arr:\\n # print(f'arr: {arr}, e: {e}, c_3: {c_3}, c_2: {c_2}, n_triplets: {n_triplets}')\\n if e in c_3:\\n n_triplets += c_3[e]\\n if e in c_2:\\n c_3[e*r] += c_2[e]\\n c_2[e*r] += 1\\n return n_triplets\",\n \"def dim_calculatorP3():\\r\\n probe_set = np.arange(1, 101)\\r\\n X = 20 - 36 + ((probe_set - 1) // 10) * 4\\r\\n Y = 2 - ((probe_set - 1) % 10) * 4\\r\\n dim = np.vstack((X, Y)).T\\r\\n return dim\",\n \"def num_points_sweep(self, start, stop, step):\\r\\n return(abs((stop - start)//step) + 1)\",\n \"def get_length(data):\\n return np.array([len(conv) for conv in data]).reshape(-1, 1)\",\n \"def count_data(self):\\n try:\\n ndata = len(self.x)\\n logger.info(\\\"Number of data points: {0}\\\".format(ndata))\\n except AttributeError:\\n logger.error(\\\"Data object has not been defined\\\")\\n ndata = 0\\n return ndata\",\n \"def get_contours_number(self):\\n ncontour = len(self.x)\\n logger.info(\\\"Number of contours: {0}\\\".format(ncontour))\\n return ncontour\",\n \"def getNumTiles(self):\\n return len(list(product(list(range(self.width+1))[1:], list(range(self.height+1))[1:])))\",\n \"def get_number_of_measurement(self):\\n used_fragments = set()\\n counter = 0\\n for fragment in self.observed_fragments:\\n num_of_isotope = 0\\n used_counter = 0\\n for i in self.mdv[fragment]:\\n num_of_isotope = num_of_isotope + 1\\n if self.mdv[fragment][i]['use'] == 'use':\\n\\n counter = counter + 1\\n used_counter = used_counter + 1\\n if num_of_isotope == used_counter:\\n used_fragments.add(fragment)\\n return counter-len(used_fragments)\",\n \"def __len__(self):\\n nsamp = self.data.shape[-1]\\n kernel = int(self.kernel * self.fs)\\n stride = int(self.stride * self.fs)\\n n_stride = int(np.ceil((nsamp - kernel) / stride) + 1)\\n return max(0, n_stride)\",\n \"def compute_track_length(points, bin_size=17):\\n pca = PCA(n_components=2)\\n length = 0.\\n if len(points) >= 2:\\n coords_pca = pca.fit_transform(points)[:, 0]\\n bins = np.arange(coords_pca.min(), coords_pca.max(), bin_size)\\n # bin_inds takes values in [1, len(bins)]\\n bin_inds = np.digitize(coords_pca, bins)\\n for b_i in np.unique(bin_inds):\\n mask = bin_inds == b_i\\n if np.count_nonzero(mask) < 2: continue\\n # Repeat PCA locally for better measurement of dx\\n # pca_axis = pca.fit_transform(points[mask])\\n pca_axis = coords_pca[mask]\\n dx = pca_axis.max() - pca_axis.min()\\n length += dx\\n return length\",\n \"def nr_points(self):\\n return len(self.x)\",\n \"def count(self) -> int:\\n return self.end_measure_num - self.start_measure_num + 1\",\n \"def n_rounds(self) -> int:\\n return self.y.shape[0]\",\n \"def num_chunking_units(self):\\n if self._source_paths:\\n return len(self._source_paths)\\n return 1\",\n \"def n_cs(self):\\n return np.size(self._cs, 0)\",\n \"def _get_observation_count(self):\\n observation_count = 0\\n for sequence in self.seq_list:\\n observation_count += sequence.shape[0] \\n \\n return observation_count\",\n \"def count(self):\\r\\n return self.data_array.size\",\n \"def get_points_number(self):\\n ncontour = self.get_contours_number\\n npoints = []\\n for i in range(0, ncontour):\\n npoints.append(len(self.x[i]))\\n return npoints\",\n \"def __len__(self):\\n return int(np.floor(len(self.dataset_df) / self.batch_size))\",\n \"def numSegments(self):\\n\\n return self.getHierView().numSegments()\",\n \"def get_stepsize(ds):\\n tube_pos = ds.axes[-1]\\n if tube_pos.ndim == 2: #very old data, just take one slice\\n tube_pos = tube_pos[0]\\n tubesep = abs(tube_pos[0]-tube_pos[-1])/(len(tube_pos)-1)\\n tube_steps = ds.axes[0]\\n bin_size = abs(tube_steps[0]-tube_steps[-1])/(len(tube_steps)-1)\\n pixel_step = int(round(tubesep/bin_size))\\n bin_size = tubesep/pixel_step\\n #print 'Determined tube separation to be %f, corresponding to %d steps' % (tubesep,pixel_step)\\n return bin_size\",\n \"def get_num_points(self):\\n dimensions = self.data.shape\\n return dimensions[0]\",\n \"def dimension(self):\",\n \"def get_number_of_segments(self):\\n\\n return len(self._break_points) - 1\",\n \"def dimensions():\",\n \"def calculate_number_of_segments(self):\\n return sum(len(eg.transcript_file.segments) for eg in self.exemplars)\",\n \"def count_segments(self, raw_only: bool = False) -> int:\\n if self.segments:\\n self_count = 0 if raw_only else 1\\n return self_count + sum(\\n seg.count_segments(raw_only=raw_only) for seg in self.segments\\n )\\n else:\\n return 1\",\n \"def dim(self) -> int:\\n pass\",\n \"def number_of_steps(self) -> int:\\n return len(self.step_points)\",\n \"def num_timesteps(self):\\n return self._num_timesteps\",\n \"def nbytes_at(self, device_id:int):\\n if self._slices:\\n if isinstance(self._coherence._local_states[device_id], dict): # there are subarrays no this device\\n if self._slices_hash in self._coherence._local_states[device_id].keys(): # this subarray is already there\\n return self._array.nbytes_at(device_id)\\n else: # the subarray will be moved to there\\n return self._array.nbytes_at(device_id) + self.subarray_nbytes # add the incoming subarray size\\n else: # there is a complete copy on this device, no need to prepare subarray\\n return self.nbytes\\n else:\\n return self.nbytes\",\n \"def count():\",\n \"def n_points(self) -> int:\\n return len(self.all_df)\",\n \"def __len__(self): \\r\\n length = len(self.data) - 2* self.skip_window\\r\\n #print ('length', length)\\r\\n return length\\r\\n #raise NotImplementedError('Implement the __len__ method of the dataset')\\r\",\n \"def n_points(self) -> int:\\n return len(self.df)\",\n \"def size(self) -> Tuple[groupable, pdarray]:\\n return self.count()\",\n \"def num_run_cycles(self, run_idx):\\n return self.num_traj_frames(run_idx, 0)\",\n \"def numberOfPoints(self):\\n return 20000\",\n \"def getLength(self):\\n lons = self._toplons\\n lats = self._toplats\\n seg = self._group_index\\n groups = np.unique(seg)\\n ng = len(groups)\\n rlength = 0\\n for i in range(ng):\\n group_segments = np.where(groups[i] == seg)[0]\\n nseg = len(group_segments) - 1\\n for j in range(nseg):\\n ind = group_segments[j]\\n P0 = Point(lons[ind], lats[ind])\\n P1 = Point(lons[ind + 1], lats[ind + 1])\\n dist = P0.distance(P1)\\n rlength = rlength + dist\\n return rlength\",\n \"def get_dimension_length(self):\\n pass\",\n \"def find_num_beats_per_window(p1, p2, p3, p4, p5, p6):\\n\\n return len(p1), len(p2), len(p3), len(p4), len(p5), len(p6)\",\n \"def __len__(self):\\r\\n return int(np.ceil(len(self.pathways) / float(self.batch_size)))\",\n \"def _get_observation_dimension(self):\\n return len(self._get_observation_np())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7135924","0.6884999","0.64077276","0.6373212","0.6304518","0.6302463","0.6214839","0.6137181","0.6126625","0.61182857","0.6099939","0.6055298","0.6052316","0.6023152","0.59912443","0.5985234","0.59840417","0.59639126","0.59609234","0.59437424","0.5941274","0.59409493","0.59409493","0.5938911","0.593823","0.5906485","0.588328","0.58790076","0.58749837","0.5840988","0.5831759","0.58248883","0.58102876","0.57956505","0.5780419","0.57775396","0.5774456","0.57719934","0.5734191","0.5718746","0.57088643","0.5708398","0.57015574","0.57015574","0.57015574","0.5697563","0.56928396","0.5680043","0.56774986","0.5669859","0.5648747","0.56308746","0.56233114","0.5617497","0.5614036","0.5612783","0.5590715","0.5590399","0.5588557","0.55870557","0.55864936","0.5583911","0.5580825","0.5574367","0.5553499","0.5546722","0.55459243","0.55295485","0.55119896","0.55115664","0.55107576","0.55060244","0.5502313","0.54934996","0.5492216","0.54901946","0.5482243","0.54818743","0.5479869","0.5472665","0.54693747","0.54636186","0.54628986","0.5462504","0.54566705","0.5450361","0.5444831","0.54419744","0.54366475","0.5436525","0.54334915","0.54281604","0.5424359","0.542419","0.5423022","0.5419185","0.5418408","0.5416286","0.5400809","0.5398093"],"string":"[\n \"0.7135924\",\n \"0.6884999\",\n \"0.64077276\",\n \"0.6373212\",\n \"0.6304518\",\n \"0.6302463\",\n \"0.6214839\",\n \"0.6137181\",\n \"0.6126625\",\n \"0.61182857\",\n \"0.6099939\",\n \"0.6055298\",\n \"0.6052316\",\n \"0.6023152\",\n \"0.59912443\",\n \"0.5985234\",\n \"0.59840417\",\n \"0.59639126\",\n \"0.59609234\",\n \"0.59437424\",\n \"0.5941274\",\n \"0.59409493\",\n \"0.59409493\",\n \"0.5938911\",\n \"0.593823\",\n \"0.5906485\",\n \"0.588328\",\n \"0.58790076\",\n \"0.58749837\",\n \"0.5840988\",\n \"0.5831759\",\n \"0.58248883\",\n \"0.58102876\",\n \"0.57956505\",\n \"0.5780419\",\n \"0.57775396\",\n \"0.5774456\",\n \"0.57719934\",\n \"0.5734191\",\n \"0.5718746\",\n \"0.57088643\",\n \"0.5708398\",\n \"0.57015574\",\n \"0.57015574\",\n \"0.57015574\",\n \"0.5697563\",\n \"0.56928396\",\n \"0.5680043\",\n \"0.56774986\",\n \"0.5669859\",\n \"0.5648747\",\n \"0.56308746\",\n \"0.56233114\",\n \"0.5617497\",\n \"0.5614036\",\n \"0.5612783\",\n \"0.5590715\",\n \"0.5590399\",\n \"0.5588557\",\n \"0.55870557\",\n \"0.55864936\",\n \"0.5583911\",\n \"0.5580825\",\n \"0.5574367\",\n \"0.5553499\",\n \"0.5546722\",\n \"0.55459243\",\n \"0.55295485\",\n \"0.55119896\",\n \"0.55115664\",\n \"0.55107576\",\n \"0.55060244\",\n \"0.5502313\",\n \"0.54934996\",\n \"0.5492216\",\n \"0.54901946\",\n \"0.5482243\",\n \"0.54818743\",\n \"0.5479869\",\n \"0.5472665\",\n \"0.54693747\",\n \"0.54636186\",\n \"0.54628986\",\n \"0.5462504\",\n \"0.54566705\",\n \"0.5450361\",\n \"0.5444831\",\n \"0.54419744\",\n \"0.54366475\",\n \"0.5436525\",\n \"0.54334915\",\n \"0.54281604\",\n \"0.5424359\",\n \"0.542419\",\n \"0.5423022\",\n \"0.5419185\",\n \"0.5418408\",\n \"0.5416286\",\n \"0.5400809\",\n \"0.5398093\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76755035"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94987,"cells":{"query":{"kind":"string","value":"Set the number of slices that belong to a given timepoint"},"document":{"kind":"string","value":"def setSlicesPerTimepoint(self, n):\n\t\tassert n > 0, \"Slices per timepoint needs to be greater than 0\"\n\t\tprint \"Setting slices per timepoint to \", n\n\t\tself.slicesPerTimepoint = n\n\t\tself.z = n\n\t\tself.readers = []"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def setNSlices(self,n):\n assert(n> 0)\n self._c_param.lee_richards_n_slices = n","def setNumTimeSubSteps(*argv):","def getSlicesPerTimepoint(self):\n\t\treturn self.slicesPerTimepoint","def _set_window_time(slices, times):\n t_idx_ = [t[-1] for t in slices]\n return times[t_idx_]","def set_numpins(self, n):\n self.numpins = n","def slice_timeseries(n_slices,dataset):\n\n n,l=np.shape(dataset)\n\n X = np.reshape(dataset,(n*n_slices,l//n_slices))\n\n print('sliced data shape (nr. of slices, slice length):',np.shape(X))\n print('#####################################')\n \n return X","def set_segments(self, segments):\n self.send_command(Command.SET_SEGMENT_COUNT, [segments])","def setNPoints(self,n):\n assert(n > 0)\n self._c_param.shrake_rupley_n_points = n","def set_slices(self, start=0.0, end=1.0, step=None, num=None):\n\n if step is None:\n s = (end - start) / float(num)\n self._slices = frange(start, end, s)\n elif num is None:\n self._slices = frange(start, end, step)\n else:\n raise RuntimeError()\n\n LOG.info('Num slices: %d', len(self._slices))\n LOG.info('Slices: %s', self._slices)","def setNumberOfIntervals(self, n=500):\n self._simulator_.update(numberOfIntervals=n)\n return","def setIterationCount(self, newIterationCount):\n \n pass","def _set_number_of_subsamples(self, number_of_subsamples):\n self._number_of_subsamples = number_of_subsamples\n self._compute_down_sample_factor()","def scale_in(self, count):\n pass","def set_number_of_time_steps(self, number_of_time_steps):\n self.number_of_time_steps = number_of_time_steps","def __init__(self, slice_number: int = -1):\n super().__init__()\n self.metric = 'SEGAREA'\n self.slice_number = slice_number","def test_write_slices(self):\n dt = np.dtype('(3,)i')\n\n data1 = np.ones((2,), dtype=dt)\n data2 = np.ones((4,5), dtype=dt)\n\n dset = self.f.create_dataset('x', (10,9,11), dtype=dt)\n\n dset[0,0,2:4] = data1\n self.assertArrayEqual(dset[0,0,2:4], data1)\n\n dset[3, 1:5, 6:11] = data2\n self.assertArrayEqual(dset[3, 1:5, 6:11], data2)","def SetDimensions(self, p_int, p_int_1, p_int_2, p_int_3, p_int_4, p_int_5, p_int_6):\n ...","def getDataSetCount(self):\n\t\treturn int(self.numberOfImages / self.slicesPerTimepoint)","def setSplitCount(self, count):\n pass","def set_t_span(self,dt,tfin):\n self.dt, self.tfin = dt,tfin\n self.t_span = np.arange(0,tfin,dt)\n return self.t_span","def plot_pcs_slice(self,data_in,large_slice,plot_slice=None,\n num_pcs=4,indiv=0, color_array=None,fs=30,sz=4):\n if color_array == None:\n color_array = self._get_colors()\n # Plot params\n fig = plt.figure(figsize=(sz,6))\n gs = GridSpec(sz+len(self.states_list),1)\n feature_ax = plt.subplot(gs[:sz,:])\n data_in = data_in[:num_pcs,large_slice][::-1,:]\n max_ = ceil(data_in.max()-data_in.min()) + 1\n ttime = np.arange(data_in.shape[1])\n for ii in range(0,num_pcs):\n feature_ax.plot(ttime,data_in[ii,:]+ii*max_,'k')\n feature_ax.set_yticks(np.arange(num_pcs)*max_)\n feature_ax.set_yticklabels('')\n\n feature_ax.set_ylim((data_in.min()-1,num_pcs*max_-1))\n\n xlabel_= np.linspace(0,data_in.shape[1],5,dtype='int')\n feature_ax.set_xticks(xlabel_)\n feature_ax.set_xlim((xlabel_[0],xlabel_[-1]))\n feature_ax.set_xticklabels(list(map(str,xlabel_ // fs)))\n\n if not (plot_slice is None):\n feature_ax.axvline(plot_slice[0], color=color_array[0],linestyle=':',lw=2)\n feature_ax.axvline(plot_slice[-1], color=color_array[0],linestyle=':',lw=2)\n plot_pcs_slice_sub(self,data_in,large_slice,plot_slice,indiv,color_array)\n return","def __init__(self, slice_number: int=-1):\n super().__init__()\n self.metric = 'GTAREA'\n self.slice_number = slice_number","def _numberOfPoints_changed(self):\n self.reinitialiseData()","def setNIterations(self, value):\n return self._set(nIterations=value)","def time_frame_stride(self, value):\n self._time_frame_stride = value","def setCount(self, num):\n self.count=num","def set_part_length(self, seconds):\n self._part_length = seconds","def setNumberOfIterations(self, value):\n return self._set(numberOfIterations=value)","def setNumberOfIterations(self, value):\n return self._set(numberOfIterations=value)","def _on_num_points_change(self, _):\n self.num_points = self.num_points_slider.value\n self.redraw_whole_plot()","def _set_neighs_slice(self, key):\n ## Condition to use slice type\n self._constant_neighs = True\n self.ks = range(1) if self.ks is None else self.ks\n ## Possible options\n if key is None:\n self.idxs = slice(0, self._n, 1)\n elif isinstance(key, slice):\n start = 0 if key.start is None else key.start\n stop = self._n if key.stop is None else key.stop\n stop = self._n if key.stop > 10*16 else key.stop\n step = 1 if key.step is None else key.step\n self.idxs = slice(start, stop, step)\n elif type(key) in inttypes:\n self.idxs = slice(0, key, 1)\n elif type(key) == tuple:\n self.idxs = slice(key[0], key[1], 1)\n self._setted = True","def time_interval_sub(self, time_step, nsteps):\n world.subtime = TimeAxis(0.0, int(nsteps), float(time_step))\n print(\"Setting subtime\")","def plot_pcs_slice_sub(self,data_in,large_slice,plot_slice,\n indiv=0,color_array=None,sz=8):\n fig = plt.figure(figsize=(sz,6))\n gs = GridSpec(sz+len(self.states_list),1)\n feature_ax = plt.subplot(gs[:sz,:])\n stateseq_ax = plt.subplot(gs[sz+1])\n\n if color_array is None:\n color_array = self._get_colors()\n\n r_plot_slice = list(map(lambda x: large_slice[0] + x, plot_slice))\n z, perm = relabel_model_z(self,index=indiv)\n z = z[r_plot_slice]\n stateseq_norep, durations = rle(z)\n\n max_ = ceil(data_in.max()-data_in.min()) +1\n data_in=data_in[:,plot_slice]\n ttime = np.arange(data_in.shape[1])\n for ii in range(0,data_in.shape[0]):\n feature_ax.plot(ttime,data_in[ii,:] + ii*max_,'k')\n\n feature_ax.set_xlim((0,len(plot_slice)))\n feature_ax.set_ylim((data_in.min()-1,data_in.shape[0]*max_-1))\n feature_ax.set_yticks([])\n feature_ax.set_xticks([])\n\n stateseq_ax.imshow(z[:,np.newaxis].T,aspect='auto',\n cmap=ListedColormap(color_array),vmin=0,vmax=len(perm))\n stateseq_ax.set_yticks([])\n stateseq_ax.set_xticks([])\n\n for ii, pos in enumerate(durations.cumsum()):\n if durations[ii] >=1:\n feature_ax.axvline(pos,\n color=color_array[stateseq_norep[ii]],\n linestyle=':')\n return","def SetDataSlice(vDataSet,arr,aIndexZ,aIndexC,aIndexT):\r\n nx = vDataSet.GetSizeX()\r\n ny = vDataSet.GetSizeY()\r\n nz = vDataSet.GetSizeZ()\r\n dtype = GetType(vDataSet)\r\n\r\n if DEBUG:\r\n print(\"SetDataVolume\")\r\n print(\"vDataSet:\",(nz,ny,nx),GetType(vDataSet))\r\n print(arr.shape)\r\n print(arr.dtype)\r\n print(aIndexC)\r\n print(aIndexT)\r\n\r\n #Make sure the data is in range and convert the array\r\n s = arr\r\n if dtype != arr.dtype:\r\n miset,maset = GetTotalRange(vDataSet)\r\n arr[arr<miset]=miset\r\n arr[arr>maset]=maset\r\n s = arr.astype(dtype)\r\n\r\n s = s.swapaxes(0,1)\r\n if dtype == np.uint8:\r\n SetData = vDataSet.SetDataSliceBytes\r\n elif dtype == np.uint16:\r\n SetData = vDataSet.SetDataSliceShorts\r\n elif dtype == np.float32:\r\n SetData = vDataSet.SetDataSliceFloat32\r\n\r\n SetData(s,aIndexZ,aIndexC,aIndexT)\r\n #vDataSet.SetChannelRange(aIndexC,miset,maset)\r","def setDimension(self, dimension):\n self.components = self.components[:dimension]\n self.components += [0 for i in range(dimension - len(self.components))]","def setIterations(self,niterations):\n self.niterations = niterations","def set_control_points(cls):\r\n \"\"\" EXECUTE THIS FUNCTION IN THE FARM CLASS! \"\"\"\r\n \r\n # t: consists of N points\r\n # p: is a finer grid made from t (default is 10 times N points)\r\n cls.t = np.fromfunction(lambda j : (1.0/2.0 + j)*cls.DT, (cls.N, ))\r\n cls.p = np.linspace(cls.t[0], cls.t[-1], num=10*cls.N)","def setNumIterations(*argv):","def set_length(stage, num):\n stage_maxes[stage] = num\n set_nums(stage)\n\n canvas.delete('tick_' + stage)\n\n if num == 0:\n return # No ticks\n\n # Draw the ticks in...\n _, y1, _, y2 = canvas.coords('bar_' + stage)\n\n dist = (width - 40) / num\n if round(dist) <= 1:\n # Don't have ticks if they're right next to each other\n return\n tag = 'tick_' + stage\n for i in range(num):\n pos = int(20 + dist*i)\n canvas.create_line(\n pos, y1, pos, y2,\n fill='#00785A',\n tags=tag,\n )\n canvas.tag_lower('tick_' + stage, 'bar_' + stage)","def test_write_slices(setup_teardown_file):\n f = setup_teardown_file[3]\n\n dt = np.dtype('(3,)i')\n\n data1 = np.ones((2, ), dtype=dt)\n data2 = np.ones((4, 5), dtype=dt)\n\n dset = f.create_dataset('x', (10, 9, 11), dtype=dt)\n\n dset[0, 0, 2:4] = data1\n assert np.array_equal(dset[0, 0, 2:4], data1)\n\n dset[3, 1:5, 6:11] = data2\n assert np.array_equal(dset[3, 1:5, 6:11], data2)","def plot_slices(hists, slice_width, fibre_pos):\n pmt_info = rat.utility().GetPMTInfo()\n # Find max angle\n max_angle = 0\n pmtIDs = hists.keys()\n for pmtID in pmtIDs:\n angle = taf.fibre_to_pmt_angle(fibre_pos, pmt_info.GetPosition(pmtID))\n if angle > max_angle:\n max_angle = angle\n print max_angle\n\n # Step between 0 and max_angle in slices of slice_width\n # create a plot of all pmt time spectra within each slice\n ROOT.gStyle.SetPalette(1) \n cuts = np.arange(0., max_angle+slice_width, slice_width)\n for i, cut in enumerate(cuts): \n tmpHists = []\n if i > 0:\n low_range = cuts[i-1]\n hi_range = cuts[i]\n s = ROOT.THStack(\"stack\", \"Slice: %1.1f - %1.1f deg\" % (low_range, hi_range)) \n count = 0\n for pmtID in pmtIDs:\n angle = taf.fibre_to_pmt_angle(fibre_pos, pmt_info.GetPosition(pmtID))\n if angle > low_range and angle < hi_range:\n #print pmtID\n count = count + 1\n hists[pmtID].SetLineColor(count)\n s.Add(hists[pmtID])\n print \"Drawing...\"\n s.Draw(\"nostack\")\n s.GetHistogram().GetXaxis().SetTitle(\"Time (ns)\")\n #s.Write()\n #c1.BuildLegend(0.5, 0.2, 0.88, 0.88)\n c1.Update()\n c1.Modified()\n c1.Print(\"./results/slices/Slice_%1.1f.png\" % low_range)\n s.Delete()\n #time.sleep(1)","def set_calculated_segments(self, total_lights, segments):\n self.set_segments(segments)\n self.set_lights_per_segment(int(total_lights / segments))","def test_n_loc(self):\n dates = pd.date_range(start=\"2007-01-01\", end=\"2007-02-01\")\n\n ts = pd.DataFrame(\n {\n \"var1\": np.arange(len(dates)),\n \"var2\": np.arange(len(dates))\n },\n index=dates)\n\n dataset = GriddedNcContiguousRaggedTs(self.testdatapath,\n self.grid,\n mode=\"w\")\n fill_values = {\"var1\": 5, \"var2\": 5}\n\n for gpi in self.gpis:\n dataset.write(gpi, ts, fill_values=fill_values)","def plot_time_slices(self):\n U = self.r.u[:, 15:-15, :]\n T = range(U.shape[2])\n kwarglist = [dict(t=t,\n index=self.index,\n U=U,\n levels=self.levels,\n fname=self.time_slice_path(t))\n for t in T]\n util.parallel_process(plot_time_slice, kwarglist=kwarglist)","def setIterations(self, value):\n return self._set(nIterations=value)","def traj_nslice (u,teq,tsample) :\n # get the number of frames in the slice (http://stackoverflow.com/a/7223557)\n traj_slice = u.trajectory[teq::tsample]\n return sum(1 for _ in traj_slice)","def traj_nslice (u,teq,tsample) :\n # get the number of frames in the slice (http://stackoverflow.com/a/7223557)\n traj_slice = u.trajectory[teq::tsample]\n return sum(1 for _ in traj_slice)","def time_slices(field=['uu1'], datadir='data/', proc=-1, extension='xz',\n format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,\n transform='plane[0]', dtstep=1, deltat=0,\n oldfile=False, outfile=\"\"):\n\n import pylab as plt\n\n datadir = os.path.expanduser(datadir)\n if outfile != \"\":\n outslice = open(outfile, \"w\")\n filename = []\n if proc < 0:\n for i in field:\n filename += [datadir + '/slice_' + i + '.' + extension]\n else:\n for i in field:\n filename += [datadir + '/proc' +\n str(proc) + '/slice_' + i + '.' + extension]\n\n # Read the global dimensions.\n dim = read_dim(datadir, proc)\n if dim.precision == 'D':\n precision = 'd'\n else:\n precision = 'f'\n\n # Set up slice plane.\n if extension == 'xy' or extension == 'Xy':\n hsize = dim.nx\n vsize = dim.ny\n if extension == 'xz':\n hsize = dim.nx\n vsize = dim.nz\n if extension == 'yz':\n hsize = dim.ny\n vsize = dim.nz\n plane = []\n infile = []\n for i in filename:\n plane += [np.zeros((vsize, hsize), dtype=precision)]\n\n infile += [npfile(i, endian=format)]\n\n ifirst = True\n islice = 0\n plotplane = []\n dt = 0\n nextt = tmin\n while True:\n try:\n raw_data = []\n for i in infile:\n raw_data += [i.fort_read(precision)]\n except ValueError:\n break\n except TypeError:\n break\n\n if oldfile:\n t = raw_data[0][-1]\n for i in range(len(raw_data)):\n plane[i] = raw_data[i][:-1].reshape(vsize, hsize)\n else:\n t = raw_data[0][-2]\n for i in range(len(raw_data)):\n plane[i] = raw_data[i][:-2].reshape(vsize, hsize)\n\n exec('tempplane =' + transform)\n\n if t > tmin and t < tmax:\n if dt == 0:\n plotplane += tempplane.tolist()\n\n if ifirst:\n #print \"----islice----------t---------min-------max-------delta\" # Python 2\n print(\"----islice----------t---------min-------max-------delta\")\n #print \"%10i %10.3e %10.3e %10.3e %10.3e\" % \\ # Python 2\n #(islice, t, tempplane.min(), tempplane.max(), # Python 2\n #tempplane.max() - tempplane.min()) # Python 2\n print(\"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\".format(islice, t, tempplane.min(), tempplane.max(), tempplane.max() - tempplane.min()))\n if outfile != \"\":\n outslice.write(\n #\"%10i %10.3e %10.3e %10.3e %10.3e\" % # Python 2\n #(islice, # Python 2\n #t, # Python 2\n #tempplane.min(), # Python 2\n #tempplane.max(), # Python 2\n #tempplane.max() - # Python 2\n #tempplane.min())) # Python 2\n \"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\".format(\n islice,\n t,\n tempplane.min(),\n tempplane.max(),\n tempplane.max() -\n tempplane.min())) \n outslice.write(\"\\n\")\n\n ifirst = False\n islice += 1\n nextt = t + deltat\n if deltat == 0:\n dt = (dt + 1) % dtstep\n elif t >= nextt:\n dt = 0\n nextt = t + deltat\n else:\n dt = 1\n\n ax = plt.axes()\n ax.set_xlabel('t')\n ax.set_ylabel('y')\n ax.set_ylim\n plt.imshow(np.array(plotplane).reshape(islice, vsize).transpose(),\n vmin=amin, vmax=amax)\n manager = plt.get_current_fig_manager()\n manager.show()\n\n for i in infile:\n i.close()\n if outfile != \"\":\n outslice.close()","def load_obstab_feedback_sliced(self, dataset='' , file ='' , datetime='' ):\n k = dataset \n F = file \n dt = datetime\n \n if dt != self.unique_dates[k][F]['up_to_dt_slice']:\n print(\"Error! the dit does not correspond to the dt I calculated in the previous loading! \")\n return 0\n \n logging.debug(\" === (Re)Load data for %s file %s counter %s\" , dataset, file, data[k][F][\"counter\"])\n print(blue + 'Memory used before reading data: ', process.memory_info().rss/1000000000 , cend)\n \n slice_size = self.slice_size\n \n file = data[k][F]['h5py_file']\n rts, ri = data[k][F][\"recordtimestamp\"][:] , data[k][F][\"recordindex\"][:]\n\n index_min = self.unique_dates[k][F]['indices'][dt]['low'] # here no offset since I am reading the original data \n ind = np.where(rts==dt)[0][0] # index of specific dt , I need the extremes indices of the next date_time after slicing \n \n try: \n up_to_dt_slice = rts[ind + slice_size ] # \n index_max = self.unique_dates[k][F]['indices'][up_to_dt_slice]['low'] # maximum index in the array of date_time to slice on\n update_index = True\n except:\n \"\"\" If the dt is too large, I take the whole array \"\"\"\n index_max = 1000000000000000\n update_index = False \n \n \n ####################\n # OBSERVATIONS TABLE\n #################### \n logging.debug ('*** Loading observations_table' )\n obs_tab = file['observations_table'] \n\n #print('CHECKING THE INDICES:::: ' , k , ' index_min ', index_min , ' index_max ', index_max )\n obs_dic= {} \n for ov in self.observations_table_vars:\n v = copy.deepcopy( obs_tab[ov][index_min:index_max ] )\n obs_dic[ov] = v \n data[k][F]['observations_table']= obs_dic \n\n ###########\n # ERA5FB\n ###########\n if k == 'era5_1' or k == 'era5_2':\n logging.debug('*** Loading era5fb ' )\n era5fb_tab = file['era5fb']\n fb_dic = {} \n for ov in self.era5fb_columns:\n try:\n v = copy.deepcopy( era5fb_tab[ov][index_min:index_max ] )\n fb_dic[ov] = v \n except:\n continue\n #print(\"CANNOT FIND \", ov ) \n \n data[k][F]['era5fb_tab']= fb_dic\n \n print(blue + 'Memory used after reading data: ', process.memory_info().rss/1000000000 , cend)\n \n \"\"\" Updating the indices \"\"\" \n self.unique_dates[k][F]['index_offset'] = copy.deepcopy( self.unique_dates[k][F]['index_offset_next'] ) \n \n if update_index: \n self.unique_dates[k][F]['index_offset_next'] = index_max \n self.unique_dates[k][F]['up_to_dt_slice'] = up_to_dt_slice\n\n return 0","def test_slice_other_dimension(setup_teardown_file):\n f = setup_teardown_file[3]\n\n for i, shape in enumerate([(3, 0), (1, 2, 0), (2, 0, 1)]):\n dset = f.create_dataset('x%d'%i, shape, dtype=np.int32)\n assert dset.shape == shape\n out = dset[:1]\n assert isinstance(out, np.ndarray)\n assert out.shape == (1,)+shape[1:]","def setSideCount(self, count):\n _count = count\n if not isinstance(_count, int):\n _count = int(count)\n if _count < 3:\n raise ValueError, \"Invalid count: %d\" % _count\n self.__nsides = _count\n self.__increment = (360.0/float(_count)) * (math.pi/180.0)\n for _i in range(_count):\n self.__xpts.insert(_i, 0.0)\n self.__ypts.insert(_i, 0.0)","def timeSlice(requestContext, seriesList, startSliceAt, endSliceAt=\"now\"):\n\n results = []\n start = time.mktime(parseATTime(startSliceAt).timetuple())\n end = time.mktime(parseATTime(endSliceAt).timetuple())\n\n for slicedSeries in seriesList:\n slicedSeries.name = 'timeSlice(%s, %s, %s)' % (slicedSeries.name, int(start), int(end))\n\n curr = time.mktime(requestContext[\"startTime\"].timetuple())\n for i, v in enumerate(slicedSeries):\n if v is None or curr < start or curr > end:\n slicedSeries[i] = None\n curr += slicedSeries.step\n\n results.append(slicedSeries)\n\n return results","def setPTLimits(*args):\n args[0].Limit.PTLimit.pt_limit = args[1]","def set_count(self, count, asset=None):\n self._set_property('pc:count', count, asset)","def setPointWidth(self, width):\n for point in self.points:\n point.width = width","def setPointSize(self, size):\n for point in self.points:\n point.size = size","def setSegmentWidth(self, width):\n for segment in self.segments:\n segment.width = width","def set_n(self, n: int) -> None:\r\n self.n_is_set = True\r\n self.n = n","def count(self):\n self.scale(end_scale=(1.5, 1.5), duration=1.5, \n rel_origin=(0.5, 0.8), harmonic=True, loop=True)","def set_t(self, Orbit):\n\t\n\tself.t = np.arange(self.t_min, self.t_max, Orbit.dt)\n\tself.N = len(self.t)\n\t\n\treturn","def from_slice(self, slice):\n\n start = 0 if slice.start is None else slice.start\n step = 1 if slice.step is None else slice.step\n return self.count(start, step, stop=slice.step)","def onSetToFourthSize(self, evt):\n\t\tself.halfResampleZ.Enable(0)\n\t\tself.fourthResampleZ.Enable(1)\n\t\tif self.dataUnits:\n\t\t\tzf = 1\n\t\t\tx, y, z = self.dataUnits[0].dataSource.getOriginalDimensions()\n\t\t\t\n\t\t\tif self.fourthResampleZ.GetValue():\n\t\t\t\tzf = 0.25\n\t\t\tself.currSize = int(0.25 * x), int(0.25 * y), int(zf * z) \n\t\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\n\t\t\tobj.Enable(0)","def n_series(self, n_series):\n\n self.container['n_series'] = n_series","def _create_slice(arr, id, reference_name, slice_start, slice_end):\n url = f\"http://{request.host}{BASE_PATH}/data?id={id}&reference_name={reference_name}&start={slice_start}&end={slice_end}\"\n arr.append({ 'url': url, })","def number_of_nodes(self, number_of_nodes):\n\n self._number_of_nodes = number_of_nodes","def setSplit(tmr_channel, total, newSecondPart):\n writeTMR(tmr_channel, TMR_CMPLD1, total-newSecondPart)\n writeTMR(tmr_channel, TMR_CMPLD2, newSecondPart)","def set_free_set_offset(self, params, n):\n raise NotImplementedError()","def set_dims(self, dataset):\n block.Block.set_dims(self, dataset)\n \n raw = dataset.blocks['raw']\n\n # local reference to input data\n data = dataset.get_source_data('prep')\n\n # this is the calculated proper size for self.data\n raw_dims = list(data.shape) # so we can compare to self.dims LIST\n\n # if we average FIDs, the dimensions change here \n raw_dims[-2] = int(raw_dims[-2]/self.set.fids_to_average)\n\n if self.dims is None:\n self._reset_dimensional_data(dataset)\n elif (self.dims)[::-1] != raw_dims: #FIXME bjs - need reverse here, ARRRRGH, why?\n self._reset_dimensional_data(dataset)\n\n # calculate measure_time array based on whether we average or not\n measure_time = list(raw.measure_time)\n nfids = len(measure_time)\n navgs = self.set.fids_to_average\n measure_time = measure_time[0::navgs]\n if (nfids % navgs) != 0:\n del measure_time[-1]\n self.measure_time = np.array(measure_time)","def _setNumber(x, y, xsize, ysize, field):\n count = 0\n xarray = np.array([x-1, x-1, x-1, x, x, x+1, x+1, x+1])\n yarray = np.array([y-1, y, y+1, y-1, y+1, y-1, y, y+1])\n for i in range(8):\n if (xarray[i] < 0) or (yarray[i] < 0):\n pass\n elif (xarray[i] > xsize-1) or (yarray[i] > ysize-1):\n pass\n else:\n if field[xarray[i], yarray[i]] == np.inf:\n count += 1\n return count","def set_free_set_offset(self, params, n):\n params.scaling_options.free_set_offset = n\n return params","def _set_sample(self, sample, PB_X, t):\n for sensor in PB_X.keys():\n sample.set(sensor, np.array(PB_X[sensor]), t=t+1)","def prepare_voxel_slice(self,slices,llc,urc,direction):\n\t\tsize=urc-llc\n\t\tres = float(size[direction] / slices)\n\t\tdims=numpy.ceil(size/res)\n\t\treturn numpy.zeros((dims[(direction+1) % 3],dims[(direction+2) % 3]),dtype='bool'), res","def setswitchinterval(n): # real signature unknown; restored from __doc__\n pass","def slice_parameters(self, slice_parameters: SliceParamsIm):\n\n self._slice_parameters = slice_parameters","def _get_slice_len(s, axlen):\n if s.start is None:\n start = 0\n else:\n start = s.start\n if s.stop is None:\n stop = axlen\n else:\n stop = np.min([s.stop, axlen])\n if s.step is None:\n step = 1\n else:\n step = s.step\n\n return ((stop - 1 - start) // step) + 1","def AddSlice(self, data_slice):\n self.slices.append(data_slice)","def set_pointsize(self, pointsize):\n\tself.m_pointsize = pointsize","def setVoxelSize(self, vxs):\n\t\tself.voxelsize = vxs\n\t\ta, b, c = vxs\n\t\tself.spacing = [1, b / a, c / a]","def set_point_size(self, point_size=0.0):\r\n for b in self.buf:\r\n b.unib[8] = point_size","def SetDataVolume(vDataSet,arr,aIndexC,aIndexT):\r\n nx = vDataSet.GetSizeX()\r\n ny = vDataSet.GetSizeY()\r\n nz = vDataSet.GetSizeZ()\r\n dtype = GetType(vDataSet)\r\n\r\n if DEBUG:\r\n print(\"SetDataVolume\")\r\n print(\"vDataSet:\",(nz,ny,nx),GetType(vDataSet))\r\n print(arr.shape)\r\n print(arr.dtype)\r\n print(aIndexC)\r\n print(aIndexT)\r\n\r\n #Make sure the data is in range and convert the array\r\n s = arr\r\n if dtype != arr.dtype:\r\n miset,maset = GetTotalRange(vDataSet)\r\n arr[arr<miset]=miset\r\n arr[arr>maset]=maset\r\n s = arr.astype(dtype)\r\n\r\n if dtype == np.uint8:\r\n SetData = vDataSet.SetDataVolumeAs1DArrayBytes\r\n s = s.tostring()\r\n elif dtype == np.uint16:\r\n SetData = vDataSet.SetDataVolumeAs1DArrayShorts\r\n s = np.ravel(s)\r\n elif dtype == np.float32:\r\n SetData = vDataSet.SetDataVolumeAs1DArrayFloats\r\n s = np.ravel(s)\r\n SetData(s,aIndexC,aIndexT)\r\n\r\n if 0:\r\n #Old method slice by slice\r\n if dtype == np.uint8:\r\n SetData = vDataSet.SetDataSubVolumeAs1DArrayBytes\r\n elif dtype == np.uint16:\r\n s = np.ravel(s)\r\n SetData = vDataSet.SetDataSubVolumeAs1DArrayShorts\r\n elif dtype == np.float32:\r\n s = np.ravel(s)\r\n SetData = vDataSet.SetDataSubVolumeAs1DArrayFloats\r\n\r\n for z in range(nz):\r\n t = time.time()\r\n l = arr[z,...].swapaxes(0,1).tostring()\r\n SetData(l,0,0,z,aIndexC,aIndexT,nx,ny,1)\r\n print z,time.time()-t\r\n\r\n #vDataSet.SetChannelRange(aIndexC,miset,maset)\r","def set_layer(self, n):\n self.layernum = n\n self.update()","def set_length(self, ak_tpl: BKT, newLength: float): # -> None:\n ...","def __init__(self):\n self.counter = [[0, x + 1] for x in range(300)]","def test_slice_setslice_forbidden(self):\n global setVal\n class foo:\n def __setslice__(self, i, j, value):\n global setVal\n setVal = i, j, value\n def __setitem__(self, index, value):\n global setVal\n setVal = index, value\n\n foo()[::] = 23\n self.assertEqual(setVal, (slice(None, None, None), 23))\n foo()[::None] = 23\n self.assertEqual(setVal, (slice(None, None, None), 23))","def chunksize(self, value):\n\n self.data.chunksize = int(value)\n self.mask.chunksize = int(value)","def onSetToCustDims(self, evt):\n\t\tself.halfResampleZ.Enable(0)\n\t\tself.fourthResampleZ.Enable(0)\n\t\t\n\t\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\n\t\t\tobj.Enable(1)\n\t\ttry:\n\t\t\trx = int(self.newDimX.GetValue())\n\t\t\try = int(self.newDimY.GetValue())\n\t\t\trz = int(self.newDimZ.GetValue())\n\t\t\tself.currSize = (rx, ry, rz)\n\t\texcept:\n\t\t\tpass","def setN(self, value):\n return self._set(n=value)","def plot_time_slice(index, t, U, fname, levels):\n fig = plt.figure()\n ax = fig.add_subplot(111)\n title = 'Time slice {r} {t:0>4d}'.format(r=index, t=t)\n ax.set_title(title)\n U = U[:, :, t]\n contourf = ax.contourf(U, levels)\n fig.colorbar(contourf)\n util.makedirs_p(os.path.dirname(fname))\n fig.savefig(fname)","def nskip(self, date, time0=None):\n time0 = self.time0 if time0 is None else Time(time0, scale='utc')\n dt = Time(date, scale='utc') - time0\n nskip = int(round((dt / self.dtsample / self.setsize)\n .to(u.dimensionless_unscaled)))\n return nskip","def set_num_selections(self, integrity):\n #p = 1-self.integrity\n p = integrity\n numerator = 1\n denominator = 1+(0.29/p)\n num_selections = numerator/denominator\n self.num_selections = int(num_selections*self.limit)","def set_n_accum(self, n):\n self.lib.SetNumberAccumulations(ct.c_int(n))","def test_slice_of_length_zero(setup_teardown_file):\n f = setup_teardown_file[3]\n\n for i, shape in enumerate([(3, ), (2, 2, ), (2, 1, 5)]):\n dset = f.create_dataset('x%d'%i, data=np.zeros(shape, np.int32))\n assert dset.shape == shape\n out = dset[1:1]\n assert isinstance(out, np.ndarray)\n assert out.shape == (0,)+shape[1:]","def setTickLength(major=24,minor=16):\n dislin.ticlen(major,minor)","def size(self):\n size = 1\n for current_slice in self.slices:\n size *= current_slice.stop - current_slice.start\n return size","def setSegments(self, segments):\n for point, segment in zip(self.points, segments):\n point.set(segment.p1)","def test_slice_zero_length_dimension(setup_teardown_file):\n f = setup_teardown_file[3]\n\n for i, shape in enumerate([(0,), (0, 3), (0, 2, 1)]):\n dset = f.create_dataset('x%d'%i, shape, dtype=np.int32)\n assert dset.shape == shape\n out = dset[...]\n assert isinstance(out, np.ndarray)\n assert out.shape == shape\n out = dset[:]\n assert isinstance(out, np.ndarray)\n assert out.shape == shape\n if len(shape) > 1:\n out = dset[:, :1]\n assert isinstance(out, np.ndarray)\n assert out.shape[:2] == (0, 1)","def set_index_ub(self, param, length):\n if tik.Dprofile().get_product_name() in (MINI, CLOUD, HISI_ES):\n sum_mask_ub = self.instance.Tensor(self.dtype, (16,),\n name=\"sum_mask_ub\",\n scope=tik.scope_ubuf)\n work_tensor_ub = self.instance.Tensor(self.dtype, (16,),\n name=\"work_tensor_ub\",\n scope=tik.scope_ubuf)\n self.instance.vec_reduce_add(self.mask, sum_mask_ub, param['reduce_mask_ub'], work_tensor_ub, 1, 8)\n\n mask_scalar = self.instance.Scalar(\"uint16\", name=\"mask_scalar\")\n mask_scalar.set_as(sum_mask_ub[0])\n with self.instance.if_scope(mask_scalar != 0):\n with self.instance.if_scope(param['count'] < PRE_NMS_TOPN):\n with self.instance.for_range(0, length) as mask_index:\n param['index_offset'].set_as(param['index_offset'] + 1)\n with self.instance.if_scope(param['count'] < PRE_NMS_TOPN):\n mask_scalar.set_as(param['reduce_mask_ub'][mask_index])\n\n # 1 fp16 == 15360 uint16\n with self.instance.if_scope(mask_scalar == 15360):\n param['index_ub'][param['count']].set_as(\n param['index_offset'])\n param['count'].set_as(param['count'] + 1)\n with self.instance.else_scope():\n param['index_offset'].set_as(param['index_offset'] + length)","def setTickNumber(n=2, axes='XYZ'):\n dislin.ticks(n, axes)","def set_time_step_size(self, delta_t):\n self.delta_t = delta_t","def multiply_slice(starting_index, len_slice=13):\n\tmultiple = 1\n\n\tfor i in range(starting_index, starting_index + len_slice):\n\t\tmultiple *= int(number[i])\n\treturn multiple"],"string":"[\n \"def setNSlices(self,n):\\n assert(n> 0)\\n self._c_param.lee_richards_n_slices = n\",\n \"def setNumTimeSubSteps(*argv):\",\n \"def getSlicesPerTimepoint(self):\\n\\t\\treturn self.slicesPerTimepoint\",\n \"def _set_window_time(slices, times):\\n t_idx_ = [t[-1] for t in slices]\\n return times[t_idx_]\",\n \"def set_numpins(self, n):\\n self.numpins = n\",\n \"def slice_timeseries(n_slices,dataset):\\n\\n n,l=np.shape(dataset)\\n\\n X = np.reshape(dataset,(n*n_slices,l//n_slices))\\n\\n print('sliced data shape (nr. of slices, slice length):',np.shape(X))\\n print('#####################################')\\n \\n return X\",\n \"def set_segments(self, segments):\\n self.send_command(Command.SET_SEGMENT_COUNT, [segments])\",\n \"def setNPoints(self,n):\\n assert(n > 0)\\n self._c_param.shrake_rupley_n_points = n\",\n \"def set_slices(self, start=0.0, end=1.0, step=None, num=None):\\n\\n if step is None:\\n s = (end - start) / float(num)\\n self._slices = frange(start, end, s)\\n elif num is None:\\n self._slices = frange(start, end, step)\\n else:\\n raise RuntimeError()\\n\\n LOG.info('Num slices: %d', len(self._slices))\\n LOG.info('Slices: %s', self._slices)\",\n \"def setNumberOfIntervals(self, n=500):\\n self._simulator_.update(numberOfIntervals=n)\\n return\",\n \"def setIterationCount(self, newIterationCount):\\n \\n pass\",\n \"def _set_number_of_subsamples(self, number_of_subsamples):\\n self._number_of_subsamples = number_of_subsamples\\n self._compute_down_sample_factor()\",\n \"def scale_in(self, count):\\n pass\",\n \"def set_number_of_time_steps(self, number_of_time_steps):\\n self.number_of_time_steps = number_of_time_steps\",\n \"def __init__(self, slice_number: int = -1):\\n super().__init__()\\n self.metric = 'SEGAREA'\\n self.slice_number = slice_number\",\n \"def test_write_slices(self):\\n dt = np.dtype('(3,)i')\\n\\n data1 = np.ones((2,), dtype=dt)\\n data2 = np.ones((4,5), dtype=dt)\\n\\n dset = self.f.create_dataset('x', (10,9,11), dtype=dt)\\n\\n dset[0,0,2:4] = data1\\n self.assertArrayEqual(dset[0,0,2:4], data1)\\n\\n dset[3, 1:5, 6:11] = data2\\n self.assertArrayEqual(dset[3, 1:5, 6:11], data2)\",\n \"def SetDimensions(self, p_int, p_int_1, p_int_2, p_int_3, p_int_4, p_int_5, p_int_6):\\n ...\",\n \"def getDataSetCount(self):\\n\\t\\treturn int(self.numberOfImages / self.slicesPerTimepoint)\",\n \"def setSplitCount(self, count):\\n pass\",\n \"def set_t_span(self,dt,tfin):\\n self.dt, self.tfin = dt,tfin\\n self.t_span = np.arange(0,tfin,dt)\\n return self.t_span\",\n \"def plot_pcs_slice(self,data_in,large_slice,plot_slice=None,\\n num_pcs=4,indiv=0, color_array=None,fs=30,sz=4):\\n if color_array == None:\\n color_array = self._get_colors()\\n # Plot params\\n fig = plt.figure(figsize=(sz,6))\\n gs = GridSpec(sz+len(self.states_list),1)\\n feature_ax = plt.subplot(gs[:sz,:])\\n data_in = data_in[:num_pcs,large_slice][::-1,:]\\n max_ = ceil(data_in.max()-data_in.min()) + 1\\n ttime = np.arange(data_in.shape[1])\\n for ii in range(0,num_pcs):\\n feature_ax.plot(ttime,data_in[ii,:]+ii*max_,'k')\\n feature_ax.set_yticks(np.arange(num_pcs)*max_)\\n feature_ax.set_yticklabels('')\\n\\n feature_ax.set_ylim((data_in.min()-1,num_pcs*max_-1))\\n\\n xlabel_= np.linspace(0,data_in.shape[1],5,dtype='int')\\n feature_ax.set_xticks(xlabel_)\\n feature_ax.set_xlim((xlabel_[0],xlabel_[-1]))\\n feature_ax.set_xticklabels(list(map(str,xlabel_ // fs)))\\n\\n if not (plot_slice is None):\\n feature_ax.axvline(plot_slice[0], color=color_array[0],linestyle=':',lw=2)\\n feature_ax.axvline(plot_slice[-1], color=color_array[0],linestyle=':',lw=2)\\n plot_pcs_slice_sub(self,data_in,large_slice,plot_slice,indiv,color_array)\\n return\",\n \"def __init__(self, slice_number: int=-1):\\n super().__init__()\\n self.metric = 'GTAREA'\\n self.slice_number = slice_number\",\n \"def _numberOfPoints_changed(self):\\n self.reinitialiseData()\",\n \"def setNIterations(self, value):\\n return self._set(nIterations=value)\",\n \"def time_frame_stride(self, value):\\n self._time_frame_stride = value\",\n \"def setCount(self, num):\\n self.count=num\",\n \"def set_part_length(self, seconds):\\n self._part_length = seconds\",\n \"def setNumberOfIterations(self, value):\\n return self._set(numberOfIterations=value)\",\n \"def setNumberOfIterations(self, value):\\n return self._set(numberOfIterations=value)\",\n \"def _on_num_points_change(self, _):\\n self.num_points = self.num_points_slider.value\\n self.redraw_whole_plot()\",\n \"def _set_neighs_slice(self, key):\\n ## Condition to use slice type\\n self._constant_neighs = True\\n self.ks = range(1) if self.ks is None else self.ks\\n ## Possible options\\n if key is None:\\n self.idxs = slice(0, self._n, 1)\\n elif isinstance(key, slice):\\n start = 0 if key.start is None else key.start\\n stop = self._n if key.stop is None else key.stop\\n stop = self._n if key.stop > 10*16 else key.stop\\n step = 1 if key.step is None else key.step\\n self.idxs = slice(start, stop, step)\\n elif type(key) in inttypes:\\n self.idxs = slice(0, key, 1)\\n elif type(key) == tuple:\\n self.idxs = slice(key[0], key[1], 1)\\n self._setted = True\",\n \"def time_interval_sub(self, time_step, nsteps):\\n world.subtime = TimeAxis(0.0, int(nsteps), float(time_step))\\n print(\\\"Setting subtime\\\")\",\n \"def plot_pcs_slice_sub(self,data_in,large_slice,plot_slice,\\n indiv=0,color_array=None,sz=8):\\n fig = plt.figure(figsize=(sz,6))\\n gs = GridSpec(sz+len(self.states_list),1)\\n feature_ax = plt.subplot(gs[:sz,:])\\n stateseq_ax = plt.subplot(gs[sz+1])\\n\\n if color_array is None:\\n color_array = self._get_colors()\\n\\n r_plot_slice = list(map(lambda x: large_slice[0] + x, plot_slice))\\n z, perm = relabel_model_z(self,index=indiv)\\n z = z[r_plot_slice]\\n stateseq_norep, durations = rle(z)\\n\\n max_ = ceil(data_in.max()-data_in.min()) +1\\n data_in=data_in[:,plot_slice]\\n ttime = np.arange(data_in.shape[1])\\n for ii in range(0,data_in.shape[0]):\\n feature_ax.plot(ttime,data_in[ii,:] + ii*max_,'k')\\n\\n feature_ax.set_xlim((0,len(plot_slice)))\\n feature_ax.set_ylim((data_in.min()-1,data_in.shape[0]*max_-1))\\n feature_ax.set_yticks([])\\n feature_ax.set_xticks([])\\n\\n stateseq_ax.imshow(z[:,np.newaxis].T,aspect='auto',\\n cmap=ListedColormap(color_array),vmin=0,vmax=len(perm))\\n stateseq_ax.set_yticks([])\\n stateseq_ax.set_xticks([])\\n\\n for ii, pos in enumerate(durations.cumsum()):\\n if durations[ii] >=1:\\n feature_ax.axvline(pos,\\n color=color_array[stateseq_norep[ii]],\\n linestyle=':')\\n return\",\n \"def SetDataSlice(vDataSet,arr,aIndexZ,aIndexC,aIndexT):\\r\\n nx = vDataSet.GetSizeX()\\r\\n ny = vDataSet.GetSizeY()\\r\\n nz = vDataSet.GetSizeZ()\\r\\n dtype = GetType(vDataSet)\\r\\n\\r\\n if DEBUG:\\r\\n print(\\\"SetDataVolume\\\")\\r\\n print(\\\"vDataSet:\\\",(nz,ny,nx),GetType(vDataSet))\\r\\n print(arr.shape)\\r\\n print(arr.dtype)\\r\\n print(aIndexC)\\r\\n print(aIndexT)\\r\\n\\r\\n #Make sure the data is in range and convert the array\\r\\n s = arr\\r\\n if dtype != arr.dtype:\\r\\n miset,maset = GetTotalRange(vDataSet)\\r\\n arr[arr<miset]=miset\\r\\n arr[arr>maset]=maset\\r\\n s = arr.astype(dtype)\\r\\n\\r\\n s = s.swapaxes(0,1)\\r\\n if dtype == np.uint8:\\r\\n SetData = vDataSet.SetDataSliceBytes\\r\\n elif dtype == np.uint16:\\r\\n SetData = vDataSet.SetDataSliceShorts\\r\\n elif dtype == np.float32:\\r\\n SetData = vDataSet.SetDataSliceFloat32\\r\\n\\r\\n SetData(s,aIndexZ,aIndexC,aIndexT)\\r\\n #vDataSet.SetChannelRange(aIndexC,miset,maset)\\r\",\n \"def setDimension(self, dimension):\\n self.components = self.components[:dimension]\\n self.components += [0 for i in range(dimension - len(self.components))]\",\n \"def setIterations(self,niterations):\\n self.niterations = niterations\",\n \"def set_control_points(cls):\\r\\n \\\"\\\"\\\" EXECUTE THIS FUNCTION IN THE FARM CLASS! \\\"\\\"\\\"\\r\\n \\r\\n # t: consists of N points\\r\\n # p: is a finer grid made from t (default is 10 times N points)\\r\\n cls.t = np.fromfunction(lambda j : (1.0/2.0 + j)*cls.DT, (cls.N, ))\\r\\n cls.p = np.linspace(cls.t[0], cls.t[-1], num=10*cls.N)\",\n \"def setNumIterations(*argv):\",\n \"def set_length(stage, num):\\n stage_maxes[stage] = num\\n set_nums(stage)\\n\\n canvas.delete('tick_' + stage)\\n\\n if num == 0:\\n return # No ticks\\n\\n # Draw the ticks in...\\n _, y1, _, y2 = canvas.coords('bar_' + stage)\\n\\n dist = (width - 40) / num\\n if round(dist) <= 1:\\n # Don't have ticks if they're right next to each other\\n return\\n tag = 'tick_' + stage\\n for i in range(num):\\n pos = int(20 + dist*i)\\n canvas.create_line(\\n pos, y1, pos, y2,\\n fill='#00785A',\\n tags=tag,\\n )\\n canvas.tag_lower('tick_' + stage, 'bar_' + stage)\",\n \"def test_write_slices(setup_teardown_file):\\n f = setup_teardown_file[3]\\n\\n dt = np.dtype('(3,)i')\\n\\n data1 = np.ones((2, ), dtype=dt)\\n data2 = np.ones((4, 5), dtype=dt)\\n\\n dset = f.create_dataset('x', (10, 9, 11), dtype=dt)\\n\\n dset[0, 0, 2:4] = data1\\n assert np.array_equal(dset[0, 0, 2:4], data1)\\n\\n dset[3, 1:5, 6:11] = data2\\n assert np.array_equal(dset[3, 1:5, 6:11], data2)\",\n \"def plot_slices(hists, slice_width, fibre_pos):\\n pmt_info = rat.utility().GetPMTInfo()\\n # Find max angle\\n max_angle = 0\\n pmtIDs = hists.keys()\\n for pmtID in pmtIDs:\\n angle = taf.fibre_to_pmt_angle(fibre_pos, pmt_info.GetPosition(pmtID))\\n if angle > max_angle:\\n max_angle = angle\\n print max_angle\\n\\n # Step between 0 and max_angle in slices of slice_width\\n # create a plot of all pmt time spectra within each slice\\n ROOT.gStyle.SetPalette(1) \\n cuts = np.arange(0., max_angle+slice_width, slice_width)\\n for i, cut in enumerate(cuts): \\n tmpHists = []\\n if i > 0:\\n low_range = cuts[i-1]\\n hi_range = cuts[i]\\n s = ROOT.THStack(\\\"stack\\\", \\\"Slice: %1.1f - %1.1f deg\\\" % (low_range, hi_range)) \\n count = 0\\n for pmtID in pmtIDs:\\n angle = taf.fibre_to_pmt_angle(fibre_pos, pmt_info.GetPosition(pmtID))\\n if angle > low_range and angle < hi_range:\\n #print pmtID\\n count = count + 1\\n hists[pmtID].SetLineColor(count)\\n s.Add(hists[pmtID])\\n print \\\"Drawing...\\\"\\n s.Draw(\\\"nostack\\\")\\n s.GetHistogram().GetXaxis().SetTitle(\\\"Time (ns)\\\")\\n #s.Write()\\n #c1.BuildLegend(0.5, 0.2, 0.88, 0.88)\\n c1.Update()\\n c1.Modified()\\n c1.Print(\\\"./results/slices/Slice_%1.1f.png\\\" % low_range)\\n s.Delete()\\n #time.sleep(1)\",\n \"def set_calculated_segments(self, total_lights, segments):\\n self.set_segments(segments)\\n self.set_lights_per_segment(int(total_lights / segments))\",\n \"def test_n_loc(self):\\n dates = pd.date_range(start=\\\"2007-01-01\\\", end=\\\"2007-02-01\\\")\\n\\n ts = pd.DataFrame(\\n {\\n \\\"var1\\\": np.arange(len(dates)),\\n \\\"var2\\\": np.arange(len(dates))\\n },\\n index=dates)\\n\\n dataset = GriddedNcContiguousRaggedTs(self.testdatapath,\\n self.grid,\\n mode=\\\"w\\\")\\n fill_values = {\\\"var1\\\": 5, \\\"var2\\\": 5}\\n\\n for gpi in self.gpis:\\n dataset.write(gpi, ts, fill_values=fill_values)\",\n \"def plot_time_slices(self):\\n U = self.r.u[:, 15:-15, :]\\n T = range(U.shape[2])\\n kwarglist = [dict(t=t,\\n index=self.index,\\n U=U,\\n levels=self.levels,\\n fname=self.time_slice_path(t))\\n for t in T]\\n util.parallel_process(plot_time_slice, kwarglist=kwarglist)\",\n \"def setIterations(self, value):\\n return self._set(nIterations=value)\",\n \"def traj_nslice (u,teq,tsample) :\\n # get the number of frames in the slice (http://stackoverflow.com/a/7223557)\\n traj_slice = u.trajectory[teq::tsample]\\n return sum(1 for _ in traj_slice)\",\n \"def traj_nslice (u,teq,tsample) :\\n # get the number of frames in the slice (http://stackoverflow.com/a/7223557)\\n traj_slice = u.trajectory[teq::tsample]\\n return sum(1 for _ in traj_slice)\",\n \"def time_slices(field=['uu1'], datadir='data/', proc=-1, extension='xz',\\n format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,\\n transform='plane[0]', dtstep=1, deltat=0,\\n oldfile=False, outfile=\\\"\\\"):\\n\\n import pylab as plt\\n\\n datadir = os.path.expanduser(datadir)\\n if outfile != \\\"\\\":\\n outslice = open(outfile, \\\"w\\\")\\n filename = []\\n if proc < 0:\\n for i in field:\\n filename += [datadir + '/slice_' + i + '.' + extension]\\n else:\\n for i in field:\\n filename += [datadir + '/proc' +\\n str(proc) + '/slice_' + i + '.' + extension]\\n\\n # Read the global dimensions.\\n dim = read_dim(datadir, proc)\\n if dim.precision == 'D':\\n precision = 'd'\\n else:\\n precision = 'f'\\n\\n # Set up slice plane.\\n if extension == 'xy' or extension == 'Xy':\\n hsize = dim.nx\\n vsize = dim.ny\\n if extension == 'xz':\\n hsize = dim.nx\\n vsize = dim.nz\\n if extension == 'yz':\\n hsize = dim.ny\\n vsize = dim.nz\\n plane = []\\n infile = []\\n for i in filename:\\n plane += [np.zeros((vsize, hsize), dtype=precision)]\\n\\n infile += [npfile(i, endian=format)]\\n\\n ifirst = True\\n islice = 0\\n plotplane = []\\n dt = 0\\n nextt = tmin\\n while True:\\n try:\\n raw_data = []\\n for i in infile:\\n raw_data += [i.fort_read(precision)]\\n except ValueError:\\n break\\n except TypeError:\\n break\\n\\n if oldfile:\\n t = raw_data[0][-1]\\n for i in range(len(raw_data)):\\n plane[i] = raw_data[i][:-1].reshape(vsize, hsize)\\n else:\\n t = raw_data[0][-2]\\n for i in range(len(raw_data)):\\n plane[i] = raw_data[i][:-2].reshape(vsize, hsize)\\n\\n exec('tempplane =' + transform)\\n\\n if t > tmin and t < tmax:\\n if dt == 0:\\n plotplane += tempplane.tolist()\\n\\n if ifirst:\\n #print \\\"----islice----------t---------min-------max-------delta\\\" # Python 2\\n print(\\\"----islice----------t---------min-------max-------delta\\\")\\n #print \\\"%10i %10.3e %10.3e %10.3e %10.3e\\\" % \\\\ # Python 2\\n #(islice, t, tempplane.min(), tempplane.max(), # Python 2\\n #tempplane.max() - tempplane.min()) # Python 2\\n print(\\\"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\\\".format(islice, t, tempplane.min(), tempplane.max(), tempplane.max() - tempplane.min()))\\n if outfile != \\\"\\\":\\n outslice.write(\\n #\\\"%10i %10.3e %10.3e %10.3e %10.3e\\\" % # Python 2\\n #(islice, # Python 2\\n #t, # Python 2\\n #tempplane.min(), # Python 2\\n #tempplane.max(), # Python 2\\n #tempplane.max() - # Python 2\\n #tempplane.min())) # Python 2\\n \\\"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}\\\".format(\\n islice,\\n t,\\n tempplane.min(),\\n tempplane.max(),\\n tempplane.max() -\\n tempplane.min())) \\n outslice.write(\\\"\\\\n\\\")\\n\\n ifirst = False\\n islice += 1\\n nextt = t + deltat\\n if deltat == 0:\\n dt = (dt + 1) % dtstep\\n elif t >= nextt:\\n dt = 0\\n nextt = t + deltat\\n else:\\n dt = 1\\n\\n ax = plt.axes()\\n ax.set_xlabel('t')\\n ax.set_ylabel('y')\\n ax.set_ylim\\n plt.imshow(np.array(plotplane).reshape(islice, vsize).transpose(),\\n vmin=amin, vmax=amax)\\n manager = plt.get_current_fig_manager()\\n manager.show()\\n\\n for i in infile:\\n i.close()\\n if outfile != \\\"\\\":\\n outslice.close()\",\n \"def load_obstab_feedback_sliced(self, dataset='' , file ='' , datetime='' ):\\n k = dataset \\n F = file \\n dt = datetime\\n \\n if dt != self.unique_dates[k][F]['up_to_dt_slice']:\\n print(\\\"Error! the dit does not correspond to the dt I calculated in the previous loading! \\\")\\n return 0\\n \\n logging.debug(\\\" === (Re)Load data for %s file %s counter %s\\\" , dataset, file, data[k][F][\\\"counter\\\"])\\n print(blue + 'Memory used before reading data: ', process.memory_info().rss/1000000000 , cend)\\n \\n slice_size = self.slice_size\\n \\n file = data[k][F]['h5py_file']\\n rts, ri = data[k][F][\\\"recordtimestamp\\\"][:] , data[k][F][\\\"recordindex\\\"][:]\\n\\n index_min = self.unique_dates[k][F]['indices'][dt]['low'] # here no offset since I am reading the original data \\n ind = np.where(rts==dt)[0][0] # index of specific dt , I need the extremes indices of the next date_time after slicing \\n \\n try: \\n up_to_dt_slice = rts[ind + slice_size ] # \\n index_max = self.unique_dates[k][F]['indices'][up_to_dt_slice]['low'] # maximum index in the array of date_time to slice on\\n update_index = True\\n except:\\n \\\"\\\"\\\" If the dt is too large, I take the whole array \\\"\\\"\\\"\\n index_max = 1000000000000000\\n update_index = False \\n \\n \\n ####################\\n # OBSERVATIONS TABLE\\n #################### \\n logging.debug ('*** Loading observations_table' )\\n obs_tab = file['observations_table'] \\n\\n #print('CHECKING THE INDICES:::: ' , k , ' index_min ', index_min , ' index_max ', index_max )\\n obs_dic= {} \\n for ov in self.observations_table_vars:\\n v = copy.deepcopy( obs_tab[ov][index_min:index_max ] )\\n obs_dic[ov] = v \\n data[k][F]['observations_table']= obs_dic \\n\\n ###########\\n # ERA5FB\\n ###########\\n if k == 'era5_1' or k == 'era5_2':\\n logging.debug('*** Loading era5fb ' )\\n era5fb_tab = file['era5fb']\\n fb_dic = {} \\n for ov in self.era5fb_columns:\\n try:\\n v = copy.deepcopy( era5fb_tab[ov][index_min:index_max ] )\\n fb_dic[ov] = v \\n except:\\n continue\\n #print(\\\"CANNOT FIND \\\", ov ) \\n \\n data[k][F]['era5fb_tab']= fb_dic\\n \\n print(blue + 'Memory used after reading data: ', process.memory_info().rss/1000000000 , cend)\\n \\n \\\"\\\"\\\" Updating the indices \\\"\\\"\\\" \\n self.unique_dates[k][F]['index_offset'] = copy.deepcopy( self.unique_dates[k][F]['index_offset_next'] ) \\n \\n if update_index: \\n self.unique_dates[k][F]['index_offset_next'] = index_max \\n self.unique_dates[k][F]['up_to_dt_slice'] = up_to_dt_slice\\n\\n return 0\",\n \"def test_slice_other_dimension(setup_teardown_file):\\n f = setup_teardown_file[3]\\n\\n for i, shape in enumerate([(3, 0), (1, 2, 0), (2, 0, 1)]):\\n dset = f.create_dataset('x%d'%i, shape, dtype=np.int32)\\n assert dset.shape == shape\\n out = dset[:1]\\n assert isinstance(out, np.ndarray)\\n assert out.shape == (1,)+shape[1:]\",\n \"def setSideCount(self, count):\\n _count = count\\n if not isinstance(_count, int):\\n _count = int(count)\\n if _count < 3:\\n raise ValueError, \\\"Invalid count: %d\\\" % _count\\n self.__nsides = _count\\n self.__increment = (360.0/float(_count)) * (math.pi/180.0)\\n for _i in range(_count):\\n self.__xpts.insert(_i, 0.0)\\n self.__ypts.insert(_i, 0.0)\",\n \"def timeSlice(requestContext, seriesList, startSliceAt, endSliceAt=\\\"now\\\"):\\n\\n results = []\\n start = time.mktime(parseATTime(startSliceAt).timetuple())\\n end = time.mktime(parseATTime(endSliceAt).timetuple())\\n\\n for slicedSeries in seriesList:\\n slicedSeries.name = 'timeSlice(%s, %s, %s)' % (slicedSeries.name, int(start), int(end))\\n\\n curr = time.mktime(requestContext[\\\"startTime\\\"].timetuple())\\n for i, v in enumerate(slicedSeries):\\n if v is None or curr < start or curr > end:\\n slicedSeries[i] = None\\n curr += slicedSeries.step\\n\\n results.append(slicedSeries)\\n\\n return results\",\n \"def setPTLimits(*args):\\n args[0].Limit.PTLimit.pt_limit = args[1]\",\n \"def set_count(self, count, asset=None):\\n self._set_property('pc:count', count, asset)\",\n \"def setPointWidth(self, width):\\n for point in self.points:\\n point.width = width\",\n \"def setPointSize(self, size):\\n for point in self.points:\\n point.size = size\",\n \"def setSegmentWidth(self, width):\\n for segment in self.segments:\\n segment.width = width\",\n \"def set_n(self, n: int) -> None:\\r\\n self.n_is_set = True\\r\\n self.n = n\",\n \"def count(self):\\n self.scale(end_scale=(1.5, 1.5), duration=1.5, \\n rel_origin=(0.5, 0.8), harmonic=True, loop=True)\",\n \"def set_t(self, Orbit):\\n\\t\\n\\tself.t = np.arange(self.t_min, self.t_max, Orbit.dt)\\n\\tself.N = len(self.t)\\n\\t\\n\\treturn\",\n \"def from_slice(self, slice):\\n\\n start = 0 if slice.start is None else slice.start\\n step = 1 if slice.step is None else slice.step\\n return self.count(start, step, stop=slice.step)\",\n \"def onSetToFourthSize(self, evt):\\n\\t\\tself.halfResampleZ.Enable(0)\\n\\t\\tself.fourthResampleZ.Enable(1)\\n\\t\\tif self.dataUnits:\\n\\t\\t\\tzf = 1\\n\\t\\t\\tx, y, z = self.dataUnits[0].dataSource.getOriginalDimensions()\\n\\t\\t\\t\\n\\t\\t\\tif self.fourthResampleZ.GetValue():\\n\\t\\t\\t\\tzf = 0.25\\n\\t\\t\\tself.currSize = int(0.25 * x), int(0.25 * y), int(zf * z) \\n\\t\\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\\n\\t\\t\\tobj.Enable(0)\",\n \"def n_series(self, n_series):\\n\\n self.container['n_series'] = n_series\",\n \"def _create_slice(arr, id, reference_name, slice_start, slice_end):\\n url = f\\\"http://{request.host}{BASE_PATH}/data?id={id}&reference_name={reference_name}&start={slice_start}&end={slice_end}\\\"\\n arr.append({ 'url': url, })\",\n \"def number_of_nodes(self, number_of_nodes):\\n\\n self._number_of_nodes = number_of_nodes\",\n \"def setSplit(tmr_channel, total, newSecondPart):\\n writeTMR(tmr_channel, TMR_CMPLD1, total-newSecondPart)\\n writeTMR(tmr_channel, TMR_CMPLD2, newSecondPart)\",\n \"def set_free_set_offset(self, params, n):\\n raise NotImplementedError()\",\n \"def set_dims(self, dataset):\\n block.Block.set_dims(self, dataset)\\n \\n raw = dataset.blocks['raw']\\n\\n # local reference to input data\\n data = dataset.get_source_data('prep')\\n\\n # this is the calculated proper size for self.data\\n raw_dims = list(data.shape) # so we can compare to self.dims LIST\\n\\n # if we average FIDs, the dimensions change here \\n raw_dims[-2] = int(raw_dims[-2]/self.set.fids_to_average)\\n\\n if self.dims is None:\\n self._reset_dimensional_data(dataset)\\n elif (self.dims)[::-1] != raw_dims: #FIXME bjs - need reverse here, ARRRRGH, why?\\n self._reset_dimensional_data(dataset)\\n\\n # calculate measure_time array based on whether we average or not\\n measure_time = list(raw.measure_time)\\n nfids = len(measure_time)\\n navgs = self.set.fids_to_average\\n measure_time = measure_time[0::navgs]\\n if (nfids % navgs) != 0:\\n del measure_time[-1]\\n self.measure_time = np.array(measure_time)\",\n \"def _setNumber(x, y, xsize, ysize, field):\\n count = 0\\n xarray = np.array([x-1, x-1, x-1, x, x, x+1, x+1, x+1])\\n yarray = np.array([y-1, y, y+1, y-1, y+1, y-1, y, y+1])\\n for i in range(8):\\n if (xarray[i] < 0) or (yarray[i] < 0):\\n pass\\n elif (xarray[i] > xsize-1) or (yarray[i] > ysize-1):\\n pass\\n else:\\n if field[xarray[i], yarray[i]] == np.inf:\\n count += 1\\n return count\",\n \"def set_free_set_offset(self, params, n):\\n params.scaling_options.free_set_offset = n\\n return params\",\n \"def _set_sample(self, sample, PB_X, t):\\n for sensor in PB_X.keys():\\n sample.set(sensor, np.array(PB_X[sensor]), t=t+1)\",\n \"def prepare_voxel_slice(self,slices,llc,urc,direction):\\n\\t\\tsize=urc-llc\\n\\t\\tres = float(size[direction] / slices)\\n\\t\\tdims=numpy.ceil(size/res)\\n\\t\\treturn numpy.zeros((dims[(direction+1) % 3],dims[(direction+2) % 3]),dtype='bool'), res\",\n \"def setswitchinterval(n): # real signature unknown; restored from __doc__\\n pass\",\n \"def slice_parameters(self, slice_parameters: SliceParamsIm):\\n\\n self._slice_parameters = slice_parameters\",\n \"def _get_slice_len(s, axlen):\\n if s.start is None:\\n start = 0\\n else:\\n start = s.start\\n if s.stop is None:\\n stop = axlen\\n else:\\n stop = np.min([s.stop, axlen])\\n if s.step is None:\\n step = 1\\n else:\\n step = s.step\\n\\n return ((stop - 1 - start) // step) + 1\",\n \"def AddSlice(self, data_slice):\\n self.slices.append(data_slice)\",\n \"def set_pointsize(self, pointsize):\\n\\tself.m_pointsize = pointsize\",\n \"def setVoxelSize(self, vxs):\\n\\t\\tself.voxelsize = vxs\\n\\t\\ta, b, c = vxs\\n\\t\\tself.spacing = [1, b / a, c / a]\",\n \"def set_point_size(self, point_size=0.0):\\r\\n for b in self.buf:\\r\\n b.unib[8] = point_size\",\n \"def SetDataVolume(vDataSet,arr,aIndexC,aIndexT):\\r\\n nx = vDataSet.GetSizeX()\\r\\n ny = vDataSet.GetSizeY()\\r\\n nz = vDataSet.GetSizeZ()\\r\\n dtype = GetType(vDataSet)\\r\\n\\r\\n if DEBUG:\\r\\n print(\\\"SetDataVolume\\\")\\r\\n print(\\\"vDataSet:\\\",(nz,ny,nx),GetType(vDataSet))\\r\\n print(arr.shape)\\r\\n print(arr.dtype)\\r\\n print(aIndexC)\\r\\n print(aIndexT)\\r\\n\\r\\n #Make sure the data is in range and convert the array\\r\\n s = arr\\r\\n if dtype != arr.dtype:\\r\\n miset,maset = GetTotalRange(vDataSet)\\r\\n arr[arr<miset]=miset\\r\\n arr[arr>maset]=maset\\r\\n s = arr.astype(dtype)\\r\\n\\r\\n if dtype == np.uint8:\\r\\n SetData = vDataSet.SetDataVolumeAs1DArrayBytes\\r\\n s = s.tostring()\\r\\n elif dtype == np.uint16:\\r\\n SetData = vDataSet.SetDataVolumeAs1DArrayShorts\\r\\n s = np.ravel(s)\\r\\n elif dtype == np.float32:\\r\\n SetData = vDataSet.SetDataVolumeAs1DArrayFloats\\r\\n s = np.ravel(s)\\r\\n SetData(s,aIndexC,aIndexT)\\r\\n\\r\\n if 0:\\r\\n #Old method slice by slice\\r\\n if dtype == np.uint8:\\r\\n SetData = vDataSet.SetDataSubVolumeAs1DArrayBytes\\r\\n elif dtype == np.uint16:\\r\\n s = np.ravel(s)\\r\\n SetData = vDataSet.SetDataSubVolumeAs1DArrayShorts\\r\\n elif dtype == np.float32:\\r\\n s = np.ravel(s)\\r\\n SetData = vDataSet.SetDataSubVolumeAs1DArrayFloats\\r\\n\\r\\n for z in range(nz):\\r\\n t = time.time()\\r\\n l = arr[z,...].swapaxes(0,1).tostring()\\r\\n SetData(l,0,0,z,aIndexC,aIndexT,nx,ny,1)\\r\\n print z,time.time()-t\\r\\n\\r\\n #vDataSet.SetChannelRange(aIndexC,miset,maset)\\r\",\n \"def set_layer(self, n):\\n self.layernum = n\\n self.update()\",\n \"def set_length(self, ak_tpl: BKT, newLength: float): # -> None:\\n ...\",\n \"def __init__(self):\\n self.counter = [[0, x + 1] for x in range(300)]\",\n \"def test_slice_setslice_forbidden(self):\\n global setVal\\n class foo:\\n def __setslice__(self, i, j, value):\\n global setVal\\n setVal = i, j, value\\n def __setitem__(self, index, value):\\n global setVal\\n setVal = index, value\\n\\n foo()[::] = 23\\n self.assertEqual(setVal, (slice(None, None, None), 23))\\n foo()[::None] = 23\\n self.assertEqual(setVal, (slice(None, None, None), 23))\",\n \"def chunksize(self, value):\\n\\n self.data.chunksize = int(value)\\n self.mask.chunksize = int(value)\",\n \"def onSetToCustDims(self, evt):\\n\\t\\tself.halfResampleZ.Enable(0)\\n\\t\\tself.fourthResampleZ.Enable(0)\\n\\t\\t\\n\\t\\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\\n\\t\\t\\tobj.Enable(1)\\n\\t\\ttry:\\n\\t\\t\\trx = int(self.newDimX.GetValue())\\n\\t\\t\\try = int(self.newDimY.GetValue())\\n\\t\\t\\trz = int(self.newDimZ.GetValue())\\n\\t\\t\\tself.currSize = (rx, ry, rz)\\n\\t\\texcept:\\n\\t\\t\\tpass\",\n \"def setN(self, value):\\n return self._set(n=value)\",\n \"def plot_time_slice(index, t, U, fname, levels):\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n title = 'Time slice {r} {t:0>4d}'.format(r=index, t=t)\\n ax.set_title(title)\\n U = U[:, :, t]\\n contourf = ax.contourf(U, levels)\\n fig.colorbar(contourf)\\n util.makedirs_p(os.path.dirname(fname))\\n fig.savefig(fname)\",\n \"def nskip(self, date, time0=None):\\n time0 = self.time0 if time0 is None else Time(time0, scale='utc')\\n dt = Time(date, scale='utc') - time0\\n nskip = int(round((dt / self.dtsample / self.setsize)\\n .to(u.dimensionless_unscaled)))\\n return nskip\",\n \"def set_num_selections(self, integrity):\\n #p = 1-self.integrity\\n p = integrity\\n numerator = 1\\n denominator = 1+(0.29/p)\\n num_selections = numerator/denominator\\n self.num_selections = int(num_selections*self.limit)\",\n \"def set_n_accum(self, n):\\n self.lib.SetNumberAccumulations(ct.c_int(n))\",\n \"def test_slice_of_length_zero(setup_teardown_file):\\n f = setup_teardown_file[3]\\n\\n for i, shape in enumerate([(3, ), (2, 2, ), (2, 1, 5)]):\\n dset = f.create_dataset('x%d'%i, data=np.zeros(shape, np.int32))\\n assert dset.shape == shape\\n out = dset[1:1]\\n assert isinstance(out, np.ndarray)\\n assert out.shape == (0,)+shape[1:]\",\n \"def setTickLength(major=24,minor=16):\\n dislin.ticlen(major,minor)\",\n \"def size(self):\\n size = 1\\n for current_slice in self.slices:\\n size *= current_slice.stop - current_slice.start\\n return size\",\n \"def setSegments(self, segments):\\n for point, segment in zip(self.points, segments):\\n point.set(segment.p1)\",\n \"def test_slice_zero_length_dimension(setup_teardown_file):\\n f = setup_teardown_file[3]\\n\\n for i, shape in enumerate([(0,), (0, 3), (0, 2, 1)]):\\n dset = f.create_dataset('x%d'%i, shape, dtype=np.int32)\\n assert dset.shape == shape\\n out = dset[...]\\n assert isinstance(out, np.ndarray)\\n assert out.shape == shape\\n out = dset[:]\\n assert isinstance(out, np.ndarray)\\n assert out.shape == shape\\n if len(shape) > 1:\\n out = dset[:, :1]\\n assert isinstance(out, np.ndarray)\\n assert out.shape[:2] == (0, 1)\",\n \"def set_index_ub(self, param, length):\\n if tik.Dprofile().get_product_name() in (MINI, CLOUD, HISI_ES):\\n sum_mask_ub = self.instance.Tensor(self.dtype, (16,),\\n name=\\\"sum_mask_ub\\\",\\n scope=tik.scope_ubuf)\\n work_tensor_ub = self.instance.Tensor(self.dtype, (16,),\\n name=\\\"work_tensor_ub\\\",\\n scope=tik.scope_ubuf)\\n self.instance.vec_reduce_add(self.mask, sum_mask_ub, param['reduce_mask_ub'], work_tensor_ub, 1, 8)\\n\\n mask_scalar = self.instance.Scalar(\\\"uint16\\\", name=\\\"mask_scalar\\\")\\n mask_scalar.set_as(sum_mask_ub[0])\\n with self.instance.if_scope(mask_scalar != 0):\\n with self.instance.if_scope(param['count'] < PRE_NMS_TOPN):\\n with self.instance.for_range(0, length) as mask_index:\\n param['index_offset'].set_as(param['index_offset'] + 1)\\n with self.instance.if_scope(param['count'] < PRE_NMS_TOPN):\\n mask_scalar.set_as(param['reduce_mask_ub'][mask_index])\\n\\n # 1 fp16 == 15360 uint16\\n with self.instance.if_scope(mask_scalar == 15360):\\n param['index_ub'][param['count']].set_as(\\n param['index_offset'])\\n param['count'].set_as(param['count'] + 1)\\n with self.instance.else_scope():\\n param['index_offset'].set_as(param['index_offset'] + length)\",\n \"def setTickNumber(n=2, axes='XYZ'):\\n dislin.ticks(n, axes)\",\n \"def set_time_step_size(self, delta_t):\\n self.delta_t = delta_t\",\n \"def multiply_slice(starting_index, len_slice=13):\\n\\tmultiple = 1\\n\\n\\tfor i in range(starting_index, starting_index + len_slice):\\n\\t\\tmultiple *= int(number[i])\\n\\treturn multiple\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6350953","0.6137186","0.58842385","0.5869937","0.56822366","0.56016797","0.5523093","0.5513194","0.54768455","0.5377458","0.5337342","0.5313137","0.5259041","0.5251777","0.52457607","0.5220166","0.5212587","0.52124","0.52096623","0.5208932","0.52069575","0.51825","0.5155861","0.51429486","0.5130738","0.51236975","0.5101","0.50905824","0.50905824","0.50864315","0.5071263","0.5067158","0.5056918","0.50416493","0.50392294","0.50110346","0.4999466","0.49732566","0.49684837","0.49546963","0.49459282","0.49224037","0.49170938","0.49081662","0.4906962","0.49060866","0.49060866","0.49059883","0.49040362","0.490058","0.4896172","0.4892774","0.48923996","0.4878454","0.4871208","0.48590085","0.4857186","0.48560584","0.4852769","0.48518562","0.48424405","0.4838887","0.4835871","0.48272958","0.48226804","0.48112807","0.48077324","0.47916076","0.47892195","0.47886434","0.47873196","0.47860453","0.478302","0.47794884","0.47762123","0.4774138","0.47738564","0.4771362","0.47706622","0.4770489","0.4758699","0.47533458","0.47479957","0.47477376","0.47468528","0.4731566","0.47313982","0.4726222","0.47251266","0.47214192","0.47183752","0.47146446","0.4708973","0.46964964","0.46926847","0.469115","0.46907213","0.46901634","0.46875232","0.4681169"],"string":"[\n \"0.6350953\",\n \"0.6137186\",\n \"0.58842385\",\n \"0.5869937\",\n \"0.56822366\",\n \"0.56016797\",\n \"0.5523093\",\n \"0.5513194\",\n \"0.54768455\",\n \"0.5377458\",\n \"0.5337342\",\n \"0.5313137\",\n \"0.5259041\",\n \"0.5251777\",\n \"0.52457607\",\n \"0.5220166\",\n \"0.5212587\",\n \"0.52124\",\n \"0.52096623\",\n \"0.5208932\",\n \"0.52069575\",\n \"0.51825\",\n \"0.5155861\",\n \"0.51429486\",\n \"0.5130738\",\n \"0.51236975\",\n \"0.5101\",\n \"0.50905824\",\n \"0.50905824\",\n \"0.50864315\",\n \"0.5071263\",\n \"0.5067158\",\n \"0.5056918\",\n \"0.50416493\",\n \"0.50392294\",\n \"0.50110346\",\n \"0.4999466\",\n \"0.49732566\",\n \"0.49684837\",\n \"0.49546963\",\n \"0.49459282\",\n \"0.49224037\",\n \"0.49170938\",\n \"0.49081662\",\n \"0.4906962\",\n \"0.49060866\",\n \"0.49060866\",\n \"0.49059883\",\n \"0.49040362\",\n \"0.490058\",\n \"0.4896172\",\n \"0.4892774\",\n \"0.48923996\",\n \"0.4878454\",\n \"0.4871208\",\n \"0.48590085\",\n \"0.4857186\",\n \"0.48560584\",\n \"0.4852769\",\n \"0.48518562\",\n \"0.48424405\",\n \"0.4838887\",\n \"0.4835871\",\n \"0.48272958\",\n \"0.48226804\",\n \"0.48112807\",\n \"0.48077324\",\n \"0.47916076\",\n \"0.47892195\",\n \"0.47886434\",\n \"0.47873196\",\n \"0.47860453\",\n \"0.478302\",\n \"0.47794884\",\n \"0.47762123\",\n \"0.4774138\",\n \"0.47738564\",\n \"0.4771362\",\n \"0.47706622\",\n \"0.4770489\",\n \"0.4758699\",\n \"0.47533458\",\n \"0.47479957\",\n \"0.47477376\",\n \"0.47468528\",\n \"0.4731566\",\n \"0.47313982\",\n \"0.4726222\",\n \"0.47251266\",\n \"0.47214192\",\n \"0.47183752\",\n \"0.47146446\",\n \"0.4708973\",\n \"0.46964964\",\n \"0.46926847\",\n \"0.469115\",\n \"0.46907213\",\n \"0.46901634\",\n \"0.46875232\",\n \"0.4681169\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7975833"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94988,"cells":{"query":{"kind":"string","value":"Returns the number of individual DataSets (=time points) managed by this DataSource"},"document":{"kind":"string","value":"def getDataSetCount(self):\n\t\treturn int(self.numberOfImages / self.slicesPerTimepoint)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def count(self):\n return self.data_container.count","def get_num_datasets(self, data):\n dsets = set()\n for items in data:\n dsetid = items[3]\n dsets.add(dsetid)\n return len(dsets)","def count_data(self):\n try:\n ndata = len(self.x)\n logger.info(\"Number of data points: {0}\".format(ndata))\n except AttributeError:\n logger.error(\"Data object has not been defined\")\n ndata = 0\n return ndata","def get_data_ninstances(self):\n return self.data_ninstances","def data_count(self):\n return(len(self.data))","def datacounts(self):\n return self._properties[\"datacounts\"]","def num_entries(self):\r\n raise NotImplementedError('BaseDataSource::num_entries not specified.')","def count(self):\r\n return self.data_array.size","def __len__(self):\n return len(self._timeseriesData)","def __len__(self):\n return self._dataset.size(dirs=self._dirs)","def number_of_data_nodes(self):\n return int(self._data['number_of_data_nodes'])","def data_count(self):\r\n\r\n shp = self.df.shape\r\n row_count = shp[0]\r\n return row_count","def Points_Counting(self):\n return len(self.__traectory_list)","def getNumTimeDataFiles(self):\n return self.nTimeDataFiles","def metric_data_count(self):\n\n if not self.__settings:\n return 0\n\n return len(self.__stats_table)","def count_elements_in_dataset(dataset):\n return dataset.count()","def get_n_sets(self):\n if not self._refreshed:\n self.refresh()\n return self._nSets","def NumberOfEntries(self):\n return _table.DSTable_NumberOfEntries(self)","def __len__(self):\r\n if self.is_superset:\r\n length = 0\r\n for ds in self.data:\r\n length += len(ds)\r\n return length\r\n else:\r\n return len(self.data)","def len(self):\n return self.d_series.map_partitions(\n lambda s: s.list.len(), meta=self.d_series._meta\n )","def dataCount(self, collectionName):\n count = collectionName.find().count()\n return count","def getSampleCount(self):\r\n return len(self._data)","def get_num_records(self):\n return self.__num_records","def __len__(self):\n return self.data.index.get_level_values(0).to_series().nunique()","def data_center_count(self) -> int:\n return pulumi.get(self, \"data_center_count\")","def __len__(self):\n return len(self.dataset)","def get_result_set_count(self):\n return self.db.zcount(\"soq_results\", 0, time())","def size(self) -> Tuple[groupable, pdarray]:\n return self.count()","def count(self):\n return self.size()","def size(self, index):\n return self.base_dataset.size(index)","def n_points(self) -> int:\n return len(self.all_df)","def get_number_of_datasets_in_fifo(self):\n return self.read_byte_data(APDS_9960.GESTURE_FIFO_LEVEL_REG_ADDRESS)","def dataset_size(self):\n return self.dataset.size","def get_all_dataset_counts(\n self,\n ) -> Dict[Tuple[str, int, int], int]:\n res = self._engine.execute(\n select(\n [\n PRODUCT.c.name,\n TIME_OVERVIEW.c.start_day,\n TIME_OVERVIEW.c.period_type,\n TIME_OVERVIEW.c.dataset_count,\n ]\n )\n .select_from(TIME_OVERVIEW.join(PRODUCT))\n .where(TIME_OVERVIEW.c.product_ref == PRODUCT.c.id)\n .order_by(\n PRODUCT.c.name, TIME_OVERVIEW.c.start_day, TIME_OVERVIEW.c.period_type\n )\n )\n\n return {\n (\n r.name,\n *TimePeriodOverview.from_flat_period_representation(\n r.period_type, r.start_day\n )[:2],\n ): r.dataset_count\n for r in res\n }","def __len__(self):\n return int(np.floor(len(self.dataset_df) / self.batch_size))","def getNrEntries(self):\n return len(self.data)","def get_data_count(self, collection):\n # Use 'data_count' attribute when available. It is created in the\n # BaseCollectionViewSet class.\n return (\n collection.data_count\n if hasattr(collection, \"data_count\")\n else collection.data.count()\n )","def __len__(self) -> int:\n import h5py\n\n with h5py.File(\n os.path.join(self.root, self.data_dir, self.img_file_name), \"r\"\n ) as f:\n num_datapoints: int = f[self.split][\"pv_log\"].shape[0]\n\n return num_datapoints","def __len__(self):\n return self.data.num_samples","def get_num_objects(cls):\n return cls.mum_objects","def count(self):\n\n raise NotImplementedError","def __len__(self):\n return self.tsdf.shape[0]","def __len__(self): \r\n length = len(self.data) - 2* self.skip_window\r\n #print ('length', length)\r\n return length\r\n #raise NotImplementedError('Implement the __len__ method of the dataset')\r","def NumberOfRows(self):\n return _table.DSTable_NumberOfRows(self)","def __len__(self):\n if self.settype == \"train\":\n return 64000\n else:\n return len(self.list_ids)","def numCoordsets(self):\n\n return self._n_csets","def get_count(cls):\n total = 0\n for counter in SimpleCounterShard.objects.all():\n total += counter.count\n return total","def n_series(self):\n return self.container['n_series']","def getDataCount(self, filter: t.Mapping[t.Text, t.Any] = {}\n ) -> DatasetCount:\n aggregate_data = self.getAggregateData(\n pipeline={\"count\": {\"$sum\": 1}},\n filter=filter,\n )\n count = first(aggregate_data.data)[\"count\"]\n return DatasetCount(count=count)","def size(self):\n\t\treturn self._count","def count(self):\n return len(self)","def get_loaded_temps(self):\n # The data loaded successfully as long as instance variable _data_set is updated.\n if self._data_set is None:\n return None\n else:\n return int(len(self._data_set))","def numobs(self):\n return len(self.datelist)","def test_data_source_soaps_count_get(self):\n pass","def getNumData(self):\n return len(self.data)","def test_set_count(self) -> int:\n return pulumi.get(self, \"test_set_count\")","def test_data_source_soaps_id_dynamic_datas_count_get(self):\n pass","def count(self):\n with self.pdq:\n (count,)=self.pdq.cursor().execute('select count(*) from pdq').next()\n return count","def _number_of_samples(self):\n return len(self._raw_data.samples)","def n_points(self):\n\n if self.data_reduced:\n return len(self.data_reduced[0])\n else:\n return 0","def __len__(self):\n return len(self.dataset) * self.samples_per_pair","def __len__(self):\n return self.dataset.shape[0]","def count(self, axis=None):\n return self.data.count(axis=axis)","def count(self):\n return len(self._runs)","def _get_dataset_size(loader):\n if isinstance(loader, (tuple, list)):\n return len(loader[0].dataset)\n else:\n return len(loader.dataset)","def get_number_of_measurement(self):\n num_of_meas = 0\n for time in self.mdvtc.keys():\n num_of_meas = num_of_meas + self.mdvtc[time].get_number_of_measurement()\n #\n return num_of_meas","def get_count(self):\n\n\t\treturn self.__count","def nspins(self):\n return len(self)","def count(self):\n return self.get_count()","def count(self):\n objects = self.all()\n return len(objects)","def count(self):\n return len(self.objects)","def count(self) -> int:\n return self._adapter.count()","def getNumEvents(dbsApi, dset):\n summary = getDsetSummary(dbsApi, dset)\n # it means the dataset was not produced\n if summary[0]['num_file'] == 0:\n return -1\n return summary[0]['num_event']","def sum_pandas(self):\n return len(self.panda_files)","def dim(self):\n return self._historical_data.dim","def n_points(self) -> int:\n return len(self.df)","def resource_record_set_count(self) -> int:\n return pulumi.get(self, \"resource_record_set_count\")","def getNumStatDataFiles(self):\n return self.nStatDataFiles","def dimension_count(self):\n return self._dimensionCount","def get_number_of_data_points(self):\n\n log.warning(\n \"get_number_of_data_points not implemented, values for statistical measurements such as AIC or BIC are \"\n \"unreliable\",\n )\n\n return 1.0","def getCount(self):\n return self.base.get(\"count\", [])","def __len__(self):\n return len(self.data_list)","def count(self):\n if not self.model:\n raise NameError('database model has not been set.')\n\n with self.session() as session:\n query = self.get_query(session)\n data = query.count()\n return data","def getSampleCount(self):\r\n return len(self._biom_table.SampleIds)","def numPostings(years):\n\tcount = []\n\tfor year in years:\n\t\tfilename = \"SmartEnergy\" +str(year) +\".xlsx\"\n\t\tDB = pd.read_excel(filename, sheet_name = 'Filters')\n\t\tcount.append(DB.iloc[10][1])\n\treturn count","def get_num_points(self):\n dimensions = self.data.shape\n return dimensions[0]","def dataset_size(self):\n if not self._dataset_size:\n # pylint: disable=attribute-defined-outside-init\n self._dataset_size = count_file_lines(\n self._hparams.source_dataset.files)\n return self._dataset_size","def getCount(self):\n return self.count","def tally(self):\n return self.count","def numpoints(self):\n return len(self.pars) + 1 # so dof is 1","def __len__(self):\n return self.dbms.getNbTables(self.db)","def get_count(self):\r\n return self.count","def numIncrementals(self) -> int:\n return len(self._dataArrays)","def length(self):\n return self.count","def countDataSize(self,filename):\n \n d = h5py.File(filename,'r')\n features = d['spectrometer/features'][:]\n select = self.selectData(features.astype(float), self.ifeature, d)\n N = len(features[select])\n d.close()\n\n N = (N//self.offsetLen) * self.offsetLen\n\n N = N*self.Nfeeds\n\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\n self.datasizes += [int(N/self.Nfeeds)]\n self.Nsamples += int(N)","def nrows(self):\n return len(self.__data)","def __len__(self):\n\n if self.is_finite_set:\n size = 0\n for set in self.sets:\n size += len(set)\n return size\n else:\n raise ValueError(\"'%s' is not a finite set.\" % self)","def Count(self) -> int:","def Count(self) -> int:","def Count(self) -> int:"],"string":"[\n \"def count(self):\\n return self.data_container.count\",\n \"def get_num_datasets(self, data):\\n dsets = set()\\n for items in data:\\n dsetid = items[3]\\n dsets.add(dsetid)\\n return len(dsets)\",\n \"def count_data(self):\\n try:\\n ndata = len(self.x)\\n logger.info(\\\"Number of data points: {0}\\\".format(ndata))\\n except AttributeError:\\n logger.error(\\\"Data object has not been defined\\\")\\n ndata = 0\\n return ndata\",\n \"def get_data_ninstances(self):\\n return self.data_ninstances\",\n \"def data_count(self):\\n return(len(self.data))\",\n \"def datacounts(self):\\n return self._properties[\\\"datacounts\\\"]\",\n \"def num_entries(self):\\r\\n raise NotImplementedError('BaseDataSource::num_entries not specified.')\",\n \"def count(self):\\r\\n return self.data_array.size\",\n \"def __len__(self):\\n return len(self._timeseriesData)\",\n \"def __len__(self):\\n return self._dataset.size(dirs=self._dirs)\",\n \"def number_of_data_nodes(self):\\n return int(self._data['number_of_data_nodes'])\",\n \"def data_count(self):\\r\\n\\r\\n shp = self.df.shape\\r\\n row_count = shp[0]\\r\\n return row_count\",\n \"def Points_Counting(self):\\n return len(self.__traectory_list)\",\n \"def getNumTimeDataFiles(self):\\n return self.nTimeDataFiles\",\n \"def metric_data_count(self):\\n\\n if not self.__settings:\\n return 0\\n\\n return len(self.__stats_table)\",\n \"def count_elements_in_dataset(dataset):\\n return dataset.count()\",\n \"def get_n_sets(self):\\n if not self._refreshed:\\n self.refresh()\\n return self._nSets\",\n \"def NumberOfEntries(self):\\n return _table.DSTable_NumberOfEntries(self)\",\n \"def __len__(self):\\r\\n if self.is_superset:\\r\\n length = 0\\r\\n for ds in self.data:\\r\\n length += len(ds)\\r\\n return length\\r\\n else:\\r\\n return len(self.data)\",\n \"def len(self):\\n return self.d_series.map_partitions(\\n lambda s: s.list.len(), meta=self.d_series._meta\\n )\",\n \"def dataCount(self, collectionName):\\n count = collectionName.find().count()\\n return count\",\n \"def getSampleCount(self):\\r\\n return len(self._data)\",\n \"def get_num_records(self):\\n return self.__num_records\",\n \"def __len__(self):\\n return self.data.index.get_level_values(0).to_series().nunique()\",\n \"def data_center_count(self) -> int:\\n return pulumi.get(self, \\\"data_center_count\\\")\",\n \"def __len__(self):\\n return len(self.dataset)\",\n \"def get_result_set_count(self):\\n return self.db.zcount(\\\"soq_results\\\", 0, time())\",\n \"def size(self) -> Tuple[groupable, pdarray]:\\n return self.count()\",\n \"def count(self):\\n return self.size()\",\n \"def size(self, index):\\n return self.base_dataset.size(index)\",\n \"def n_points(self) -> int:\\n return len(self.all_df)\",\n \"def get_number_of_datasets_in_fifo(self):\\n return self.read_byte_data(APDS_9960.GESTURE_FIFO_LEVEL_REG_ADDRESS)\",\n \"def dataset_size(self):\\n return self.dataset.size\",\n \"def get_all_dataset_counts(\\n self,\\n ) -> Dict[Tuple[str, int, int], int]:\\n res = self._engine.execute(\\n select(\\n [\\n PRODUCT.c.name,\\n TIME_OVERVIEW.c.start_day,\\n TIME_OVERVIEW.c.period_type,\\n TIME_OVERVIEW.c.dataset_count,\\n ]\\n )\\n .select_from(TIME_OVERVIEW.join(PRODUCT))\\n .where(TIME_OVERVIEW.c.product_ref == PRODUCT.c.id)\\n .order_by(\\n PRODUCT.c.name, TIME_OVERVIEW.c.start_day, TIME_OVERVIEW.c.period_type\\n )\\n )\\n\\n return {\\n (\\n r.name,\\n *TimePeriodOverview.from_flat_period_representation(\\n r.period_type, r.start_day\\n )[:2],\\n ): r.dataset_count\\n for r in res\\n }\",\n \"def __len__(self):\\n return int(np.floor(len(self.dataset_df) / self.batch_size))\",\n \"def getNrEntries(self):\\n return len(self.data)\",\n \"def get_data_count(self, collection):\\n # Use 'data_count' attribute when available. It is created in the\\n # BaseCollectionViewSet class.\\n return (\\n collection.data_count\\n if hasattr(collection, \\\"data_count\\\")\\n else collection.data.count()\\n )\",\n \"def __len__(self) -> int:\\n import h5py\\n\\n with h5py.File(\\n os.path.join(self.root, self.data_dir, self.img_file_name), \\\"r\\\"\\n ) as f:\\n num_datapoints: int = f[self.split][\\\"pv_log\\\"].shape[0]\\n\\n return num_datapoints\",\n \"def __len__(self):\\n return self.data.num_samples\",\n \"def get_num_objects(cls):\\n return cls.mum_objects\",\n \"def count(self):\\n\\n raise NotImplementedError\",\n \"def __len__(self):\\n return self.tsdf.shape[0]\",\n \"def __len__(self): \\r\\n length = len(self.data) - 2* self.skip_window\\r\\n #print ('length', length)\\r\\n return length\\r\\n #raise NotImplementedError('Implement the __len__ method of the dataset')\\r\",\n \"def NumberOfRows(self):\\n return _table.DSTable_NumberOfRows(self)\",\n \"def __len__(self):\\n if self.settype == \\\"train\\\":\\n return 64000\\n else:\\n return len(self.list_ids)\",\n \"def numCoordsets(self):\\n\\n return self._n_csets\",\n \"def get_count(cls):\\n total = 0\\n for counter in SimpleCounterShard.objects.all():\\n total += counter.count\\n return total\",\n \"def n_series(self):\\n return self.container['n_series']\",\n \"def getDataCount(self, filter: t.Mapping[t.Text, t.Any] = {}\\n ) -> DatasetCount:\\n aggregate_data = self.getAggregateData(\\n pipeline={\\\"count\\\": {\\\"$sum\\\": 1}},\\n filter=filter,\\n )\\n count = first(aggregate_data.data)[\\\"count\\\"]\\n return DatasetCount(count=count)\",\n \"def size(self):\\n\\t\\treturn self._count\",\n \"def count(self):\\n return len(self)\",\n \"def get_loaded_temps(self):\\n # The data loaded successfully as long as instance variable _data_set is updated.\\n if self._data_set is None:\\n return None\\n else:\\n return int(len(self._data_set))\",\n \"def numobs(self):\\n return len(self.datelist)\",\n \"def test_data_source_soaps_count_get(self):\\n pass\",\n \"def getNumData(self):\\n return len(self.data)\",\n \"def test_set_count(self) -> int:\\n return pulumi.get(self, \\\"test_set_count\\\")\",\n \"def test_data_source_soaps_id_dynamic_datas_count_get(self):\\n pass\",\n \"def count(self):\\n with self.pdq:\\n (count,)=self.pdq.cursor().execute('select count(*) from pdq').next()\\n return count\",\n \"def _number_of_samples(self):\\n return len(self._raw_data.samples)\",\n \"def n_points(self):\\n\\n if self.data_reduced:\\n return len(self.data_reduced[0])\\n else:\\n return 0\",\n \"def __len__(self):\\n return len(self.dataset) * self.samples_per_pair\",\n \"def __len__(self):\\n return self.dataset.shape[0]\",\n \"def count(self, axis=None):\\n return self.data.count(axis=axis)\",\n \"def count(self):\\n return len(self._runs)\",\n \"def _get_dataset_size(loader):\\n if isinstance(loader, (tuple, list)):\\n return len(loader[0].dataset)\\n else:\\n return len(loader.dataset)\",\n \"def get_number_of_measurement(self):\\n num_of_meas = 0\\n for time in self.mdvtc.keys():\\n num_of_meas = num_of_meas + self.mdvtc[time].get_number_of_measurement()\\n #\\n return num_of_meas\",\n \"def get_count(self):\\n\\n\\t\\treturn self.__count\",\n \"def nspins(self):\\n return len(self)\",\n \"def count(self):\\n return self.get_count()\",\n \"def count(self):\\n objects = self.all()\\n return len(objects)\",\n \"def count(self):\\n return len(self.objects)\",\n \"def count(self) -> int:\\n return self._adapter.count()\",\n \"def getNumEvents(dbsApi, dset):\\n summary = getDsetSummary(dbsApi, dset)\\n # it means the dataset was not produced\\n if summary[0]['num_file'] == 0:\\n return -1\\n return summary[0]['num_event']\",\n \"def sum_pandas(self):\\n return len(self.panda_files)\",\n \"def dim(self):\\n return self._historical_data.dim\",\n \"def n_points(self) -> int:\\n return len(self.df)\",\n \"def resource_record_set_count(self) -> int:\\n return pulumi.get(self, \\\"resource_record_set_count\\\")\",\n \"def getNumStatDataFiles(self):\\n return self.nStatDataFiles\",\n \"def dimension_count(self):\\n return self._dimensionCount\",\n \"def get_number_of_data_points(self):\\n\\n log.warning(\\n \\\"get_number_of_data_points not implemented, values for statistical measurements such as AIC or BIC are \\\"\\n \\\"unreliable\\\",\\n )\\n\\n return 1.0\",\n \"def getCount(self):\\n return self.base.get(\\\"count\\\", [])\",\n \"def __len__(self):\\n return len(self.data_list)\",\n \"def count(self):\\n if not self.model:\\n raise NameError('database model has not been set.')\\n\\n with self.session() as session:\\n query = self.get_query(session)\\n data = query.count()\\n return data\",\n \"def getSampleCount(self):\\r\\n return len(self._biom_table.SampleIds)\",\n \"def numPostings(years):\\n\\tcount = []\\n\\tfor year in years:\\n\\t\\tfilename = \\\"SmartEnergy\\\" +str(year) +\\\".xlsx\\\"\\n\\t\\tDB = pd.read_excel(filename, sheet_name = 'Filters')\\n\\t\\tcount.append(DB.iloc[10][1])\\n\\treturn count\",\n \"def get_num_points(self):\\n dimensions = self.data.shape\\n return dimensions[0]\",\n \"def dataset_size(self):\\n if not self._dataset_size:\\n # pylint: disable=attribute-defined-outside-init\\n self._dataset_size = count_file_lines(\\n self._hparams.source_dataset.files)\\n return self._dataset_size\",\n \"def getCount(self):\\n return self.count\",\n \"def tally(self):\\n return self.count\",\n \"def numpoints(self):\\n return len(self.pars) + 1 # so dof is 1\",\n \"def __len__(self):\\n return self.dbms.getNbTables(self.db)\",\n \"def get_count(self):\\r\\n return self.count\",\n \"def numIncrementals(self) -> int:\\n return len(self._dataArrays)\",\n \"def length(self):\\n return self.count\",\n \"def countDataSize(self,filename):\\n \\n d = h5py.File(filename,'r')\\n features = d['spectrometer/features'][:]\\n select = self.selectData(features.astype(float), self.ifeature, d)\\n N = len(features[select])\\n d.close()\\n\\n N = (N//self.offsetLen) * self.offsetLen\\n\\n N = N*self.Nfeeds\\n\\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\\n self.datasizes += [int(N/self.Nfeeds)]\\n self.Nsamples += int(N)\",\n \"def nrows(self):\\n return len(self.__data)\",\n \"def __len__(self):\\n\\n if self.is_finite_set:\\n size = 0\\n for set in self.sets:\\n size += len(set)\\n return size\\n else:\\n raise ValueError(\\\"'%s' is not a finite set.\\\" % self)\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7276192","0.7221659","0.72136873","0.7015325","0.69837743","0.68426126","0.6835689","0.6830701","0.6756762","0.66132236","0.6597357","0.65931714","0.65570873","0.6531572","0.6491252","0.64376664","0.6436097","0.6429143","0.642638","0.6403021","0.6397654","0.63931596","0.63931406","0.6380524","0.6339096","0.6327278","0.6325876","0.6319374","0.6318805","0.63138866","0.63003045","0.6297256","0.6283697","0.62796164","0.6264214","0.62595505","0.6255302","0.625098","0.6245024","0.6243325","0.6179734","0.61540115","0.615167","0.6123423","0.61196154","0.61132866","0.61123437","0.6107287","0.61067814","0.6104321","0.6095845","0.6092341","0.60891366","0.6084064","0.6083234","0.60792243","0.60721445","0.6070228","0.6064453","0.6057428","0.6050286","0.6049808","0.6041182","0.60402495","0.6038916","0.60320735","0.60268146","0.60254765","0.6021886","0.6013794","0.6013709","0.6011516","0.60094833","0.6001444","0.59982216","0.59862095","0.59851784","0.59780717","0.597463","0.5963324","0.5949581","0.5949581","0.5948882","0.5936727","0.59352684","0.59323776","0.5932301","0.5931923","0.5931417","0.5931261","0.5919807","0.59165865","0.59165335","0.59035915","0.59008366","0.58992636","0.5897145","0.5894442","0.5894442","0.5894442"],"string":"[\n \"0.7276192\",\n \"0.7221659\",\n \"0.72136873\",\n \"0.7015325\",\n \"0.69837743\",\n \"0.68426126\",\n \"0.6835689\",\n \"0.6830701\",\n \"0.6756762\",\n \"0.66132236\",\n \"0.6597357\",\n \"0.65931714\",\n \"0.65570873\",\n \"0.6531572\",\n \"0.6491252\",\n \"0.64376664\",\n \"0.6436097\",\n \"0.6429143\",\n \"0.642638\",\n \"0.6403021\",\n \"0.6397654\",\n \"0.63931596\",\n \"0.63931406\",\n \"0.6380524\",\n \"0.6339096\",\n \"0.6327278\",\n \"0.6325876\",\n \"0.6319374\",\n \"0.6318805\",\n \"0.63138866\",\n \"0.63003045\",\n \"0.6297256\",\n \"0.6283697\",\n \"0.62796164\",\n \"0.6264214\",\n \"0.62595505\",\n \"0.6255302\",\n \"0.625098\",\n \"0.6245024\",\n \"0.6243325\",\n \"0.6179734\",\n \"0.61540115\",\n \"0.615167\",\n \"0.6123423\",\n \"0.61196154\",\n \"0.61132866\",\n \"0.61123437\",\n \"0.6107287\",\n \"0.61067814\",\n \"0.6104321\",\n \"0.6095845\",\n \"0.6092341\",\n \"0.60891366\",\n \"0.6084064\",\n \"0.6083234\",\n \"0.60792243\",\n \"0.60721445\",\n \"0.6070228\",\n \"0.6064453\",\n \"0.6057428\",\n \"0.6050286\",\n \"0.6049808\",\n \"0.6041182\",\n \"0.60402495\",\n \"0.6038916\",\n \"0.60320735\",\n \"0.60268146\",\n \"0.60254765\",\n \"0.6021886\",\n \"0.6013794\",\n \"0.6013709\",\n \"0.6011516\",\n \"0.60094833\",\n \"0.6001444\",\n \"0.59982216\",\n \"0.59862095\",\n \"0.59851784\",\n \"0.59780717\",\n \"0.597463\",\n \"0.5963324\",\n \"0.5949581\",\n \"0.5949581\",\n \"0.5948882\",\n \"0.5936727\",\n \"0.59352684\",\n \"0.59323776\",\n \"0.5932301\",\n \"0.5931923\",\n \"0.5931417\",\n \"0.5931261\",\n \"0.5919807\",\n \"0.59165865\",\n \"0.59165335\",\n \"0.59035915\",\n \"0.59008366\",\n \"0.58992636\",\n \"0.5897145\",\n \"0.5894442\",\n \"0.5894442\",\n \"0.5894442\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.79010725"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94989,"cells":{"query":{"kind":"string","value":"Timepoint i i The timepoint to return"},"document":{"kind":"string","value":"def getDataSet(self, i, raw = 0):\n\t\tdata = self.getTimepoint(i)\n\t\tif self.isRGB and self.numberOfComponents == 4:\n\t\t\textract = vtk.vtkImageExtractComponents()\n\t\t\textract.SetComponents(0, 1, 2)\n\t\t\textract.SetInput(data)\n\t\t\tdata = extract.GetOutput()\n\n\t\tif self.flipVertically:\n\t\t\tflip = vtk.vtkImageFlip()\n\t\t\tflip.SetFilteredAxis(1)\n\t\t\tflip.SetInput(data)\n\t\t\tdata = flip.GetOutput()\n\t\tif self.flipHorizontally:\n\t\t\tflip = vtk.vtkImageFlip()\n\t\t\tflip.SetFilteredAxis(0)\n\t\t\tflip.SetInput(data)\n\t\t\tdata = flip.GetOutput()\n\t\t\t\n\t\treturn data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_time_points(self):\n return self._time","def time(self):\r\n raise NotImplementedError","def setTimepoint(self, tp):\n\t\tpass","def time(self):\n return self._begin","def t0(self):\n return self._time_axis.start","def get_time(self):\n start=''\n end=''\n time=''\n times=self.times\n print(times[self.istep])\n if self.istep > 0:\n start=ncEarth.beginstr % times[self.istep].isoformat()\n\n\n if self.istep < len(times)-2:\n end = ncEarth.endstr % times[self.istep+1].isoformat()\n\n if start is not '' or end is not '':\n time=ncEarth.timestr % {'begin':start,'end':end}\n\n return time","def oneTimepoint(timepoint):\n\tt = []\n\tfor vs in timepoint:\n\t\tt.append((timepoint.attrib.get('CollectionTime'), vs[0].text, vs[1].text))\n\treturn(t)","def start_time(self) -> float:\r\n ...","def get_time(self) -> float:\n raise NotImplementedError()","def timeofflight(xhat0):\n\t\timport poincare\n\t\t#Find the point on the computed poincare section, closest to the x0\n\t\timin = np.argmin(np.linalg.norm(ps[:,1:5]-xhat0, axis=1))\n\t\t#Take its time of flight as\n\t\tif imin < np.size(ps,0)-1: \n\t\t\tTapproximate = ps[imin+1,0]-ps[imin,0]\n\t\telse:\n\t\t\tTapproximate = ps[imin,0]-ps[imin-1,0]\n\t\tprint(\"Tapproximate:\")\n\t\tprint(Tapproximate)\n\t\t#Integrate for a little bit longer than the approximated integration time:\n\t\tstoptime = 1.2*Tapproximate\n\t\tnumpoints = int(stoptime/0.01)\n\t\t#Integration time array:\n\t\tt = np.linspace(0, stoptime, numpoints)\n\t\txhatphi0 = np.append(xhat0, np.array([0], float))\n\t\txhatsol = twomode.intslice(xhatphi0, t, abserror=1.0e-14, relerror=1.0e-12)\n\t\ttx = np.append(np.array([t], float).transpose(), xhatsol, axis=1)\n\t\t#Compute Poincare section:\n\t\tpsreturn=poincare.computeps(tx, reqv, nhat, 1)\n\t\tprint(\"psreturn:\")\n\t\tprint(psreturn)\n\t\t#Take the time nearest to the approximated time. This is due to the\n\t\t#fact that the array ps sometimes includes the initial point and sometimes\n\t\t#does not, hence we are not always sure the position of the first return.\n\t\titof = np.argmin(np.abs(psreturn[:,0]-Tapproximate))\n\t\ttof = psreturn[itof,0]\n\t\treturn tof","def at(self, t):\n return self.start + (self.end - self.start) * t","def current_time_step(self) -> ts.TimeStep:\n return self._current_time_step","def gettime(self):\n return self.t","def time(self):\n raise NotImplementedError()","def getTimes():","def getTimes():","def getTimes():","def current_time(cls) -> float:","def get_time(self):\n return self.get_timed() / 10.0","def initialTime(self):\n return self.params['t0']","def startTime(self) -> float:\n try: return self.times[0]\n except IndexError: return 0.0","def compute_time_step():\n\n dt = Hydro.compute_time_step()\n\n return dt","def time(self):\n return sum(self._interval) * .5","def time(self):\n return self.time_array","def get_point_at(self, t):\n segment = self.get_segment_for_time(t)\n return segment.point_at(t)","def timeStep(self):\n return self.params['h']","def wall_time(self):","def get_time(self):\n return numpy.linspace(self.header.time_gate_start, \\\n self.header.time_gate_stop, self.num_time_bins())","def round_trip_time(self):\n ...","def __call__(self, t):\n \n c = c1 = c2 = 0\n d = d1 = d2 = None\n while d1==None or d2==None or d<=d2:\n _t = self.time(c)\n if _t == None:\n break\n else:\n d = abs(t - _t)\n if d1 == None or d<d1:\n c1, d1 = c, d\n elif d2 == None or d<d2:\n c2, d2 = c, d\n c += 1\n t1, t2 = map(self.time, [c1, c2])\n v1, v2 = map(self.__getitem__, [c1, c2])\n # a lo mejor la lista solo contiene un elemento\n if t1 == t2:\n return v1\n else:\n # si contiene por lo menos dos, pues interpolacion lineal\n return (v2*(t - t1) - v1*(t - t2))/(t2 - t1)","def getPivotPointKeyTime(self, index, view) -> float:\n ...","def get_time(t):\n return [time.clock()-t[0], time.time()-t[1]]","def evaluate(self, time) -> float:\n ...","def range(self):\n return self.times[0], self.times[-1]","def time_return(self):\n return self.time","def get_imeastime(self):\n return self.itime","def time_step(self):\n return self._time_step","def target(self, time, points, dt, num_way):\n start_index = min(int(time / dt), num_way - 1)\n end_index = min(start_index + 1, num_way - 1)\n start_point = points[start_index]\n end_point = points[end_index]\n fraction = float(time % dt) / dt\n return linear_interpolation_two_points(start_point, end_point, fraction).reshape(3)","def mapRetime(ti, timelineTime):\n return ti.sourceIn() + int((timelineTime - ti.timelineIn()) * ti.playbackSpeed())","def time(self) -> int:\n pass","def time(self):\n try:\n if self.single_date:\n return self.stime\n else:\n return self.stime + (self.etime - self.stime) / 2\n except TypeError:\n return None","def time_based(t, eta_init, last_eta, d = 0.01):\n return last_eta/(1+d*t)","def get_time_step(self):\n return self._time_step","def _get_half_time(self):\n return self.__half_time","def now(self):\n return self._startTime + self.timeToOffset(self.currentTime, self._timeScale)","def GetTime(self, *args, **kwargs):\n pass","def Tt(s_c, point, system):\n Tx = tra(s_c, point, system)\n Tx.get_time()\n return Tx.time","def getTime(self):\n return self.time","def _omori_time(integ, c, p):\n if p == 1:\n return c*(exp(integ) - 1)\n else:\n return (integ*(1 - p) + c**(1 - p))**(1/(1 - p)) - c","def time(self):\n return self[self.time_columns]","def time(self):\n return self[self.time_columns]","def getTime(self) -> float:\n return self.t","def timeRange(self):\r\n _times = self.getTimes()\r\n return _times[0], _times[-1]","def time_slot(self):\n min_time = self.introduction_time or 0\n current_time = self.agent.evaluation_context.get_current_time()\n assert isinstance(current_time, Number)\n if current_time < min_time:\n return None\n num = divmod(current_time - min_time, self.__period)[0] + 1\n start = min_time + (num - 1) * self.period\n end = start + self.period\n return num, start, end","def ctime(self): # real signature unknown; restored from __doc__\r\n pass","def exposuretime(self):\n _, = self.exposuretimes\n return _","def get_time_info(self):\n\n raise NotImplementedError","def get_time(self):\n return self.time_param","def getTime(self):\n return self.step / (self.max_step + int(self.include))","def getStartTime(self):\n raise NotImplementedError","def time_function(t):\n\n omega = np.pi\n return np.sin(omega * t) + np.sin(10 * omega * t) + np.sin(20 * omega * t)","def get_times(self):\n raise NotImplementedError(\"Abstract method not implemented.\")","def time_slot(self):\n pass","def __getitem__(self, index: datetime.time) -> float:\n\n # If the index is in the profile, return the index.\n if index in self._profile:\n return self._profile[index]\n\n # If the index is not in the profile, then the closest value needs to be\n # determined. If there is a tie, this does not matter.\n delta_t_to_t_map = {\n (\n abs(\n time.hour * 3600\n + time.minute * 60\n + time.second\n - (index.hour * 3600 + index.minute * 60 + index.second)\n )\n ): time\n for time in self._profile\n }\n return self._profile[delta_t_to_t_map[min(delta_t_to_t_map)]]","def getSimulationTime(self):\r\n raise NotImplementedError()","def time(self):\n return Time(self.hour, self.minute, self.second)","def calculate_time(ix, xi, wf):\n wf_len = len(wf)\n x_time = np.arange(ix, (ix + wf_len * xi), xi)\n return x_time","def T(self, point = -1):\n return self.solution('T', point)","def tend(self):\n return self.tstart + self.duration","def get_time(self):\n return self.time","def getStartTime(self):\n return _osgAnimation.Vec2LinearSampler_getStartTime(self)","def __get_time_span(self):\n\n nonzero = self.data[\"time\"].nonzero()\n return iso_time.time(self.data[\"time\"][nonzero[0][0]]), iso_time.time(\n self.data[\"time\"][nonzero[0][-1]])","def at(self, t):\r\n return TimeArray(self[self.index_at(t)], time_unit=self.time_unit)","def time(self):\r\n return self._idx","def endTime(self) -> float:\n try: return self.times[-1]\n except IndexError: return 0.0","def start_time(self):\n # TODO: use pd.Timestamp instead\n return self.time[0].to_pydatetime()","def next_change(self, t=None):\n if t is None:\n t = self.engine.get_now()\n t -= self.initTime\n\n p = float(self.period) / POINTS_PER_CYCLE\n t2 = math.floor(t / p) * p + p\n\n t2 += self.initTime\n\n return t2","def time(self):\n return time(\n self.hour, self.minute, self.second, self.microsecond, fold=self.fold\n )","def t0(self):\n return self._t0","def get_time(self):\n return self._ticks","def constructTimeLineItem(self):\n\t\treturn","def evaluateTime(self, *args):\n return _osgAnimation.Motion_evaluateTime(self, *args)","def __call__ (self, t):\n #if t <= self.last_t:\n #raise SpaceTimeContinuumError(\n #\"We're moving back in time! Last t = {}, now = {}\".format(\n #self.last_t, t))\n\n #samp = self._sample(t)\n #self.last_t = t\n #self.last_samp = samp\n #return samp\n pass","def getStartTime(self):\n return _osgAnimation.Vec4LinearSampler_getStartTime(self)","def gettime(self):\n interval, value = _timerfd._timerfd.gettime(self)\n interval = self._join_time(*interval)\n value = self._join_time(*value)\n return interval, value","def GetTime(self):\n return self.hour, self.minute, self.second","def getStartTime(self):\n return _osgAnimation.Vec3LinearSampler_getStartTime(self)","def test_time(self):\r\n pass","def _tv_pointwise(data):\n return np.maximum(\n 0,\n np.ceil(\n (np.expand_dims(data.meeting_time - data.lag, -1) - np.arange(data.x.shape[0]))\n / data.lag\n ),\n )","def min_time(self):\n #{{{ function to return time of first sample\n\n return self.mintime","def _ith_point(self, i):\n if self.start is S.NegativeInfinity:\n initial = self.stop\n else:\n initial = self.start\n\n if self.start is S.NegativeInfinity:\n step = -1\n else:\n step = 1\n\n return initial + i*step","def inter_arrival_times(self):\n # this function returns arrival times between two subsequent tuples in ms\n # task mean_inter_arrival_time std_inter_arrival_time\n if self.inter_arrival_time is None:\n if self.tuple_arrival is None:\n self.tuple_arrivals()\n self.inter_arrival_time = convert_throughput_to_inter_arr_times(self.tuple_arrival)\n\n return self.inter_arrival_time","def PTS(self):","def get_reltriggertimes(self):\n return np.array(self.trtimes)-self.soundstarttime","def time(self):\n\t\treturn self._time","def REAL_TIME_ADVANCE(dt):","def at(self, t, tol=None):\r\n return self.data[..., self.time.index_at(t)]","def step(self):\n\n e = self.event_queue.get()\n self.current_time = e.time\n component = e.component\n component.output(self.current_time)\n component.input(self.current_time)\n component.fire()\n\n self.event_queue.put(VirtualTimeScheduler.Event(self.current_time + component.interval, component))\n\n return self.current_time","def get_time() -> int:\n return store.time","def getSegment(self, t: float, endBehavior: str = 'halt') -> Tuple[int,float]:\n if len(self.times)==0:\n raise ValueError(\"Empty trajectory\")\n if len(self.times)==1:\n return (-1,0)\n if t > self.times[-1]:\n if endBehavior == 'loop':\n try:\n t = t % self.times[-1]\n except ZeroDivisionError:\n t = 0\n else:\n return (len(self.milestones)-1,0)\n if t >= self.times[-1]:\n return (len(self.milestones)-1,0)\n if t <= self.times[0]:\n return (-1,0)\n i = bisect.bisect_right(self.times,t)\n p=i-1\n assert i > 0 and i < len(self.times),\"Invalid time index \"+str(t)+\" in \"+str(self.times)\n u=(t-self.times[p])/(self.times[i]-self.times[p])\n if i==0:\n if endBehavior == 'loop':\n t = t + self.times[-1]\n p = -2\n u=(t-self.times[p])/(self.times[-1]-self.times[p])\n else:\n return (-1,0)\n assert u >= 0 and u <= 1\n return (p,u)","def get_time_walking(self):\n return self.time_step_to_enqueue - self.time_entered"],"string":"[\n \"def get_time_points(self):\\n return self._time\",\n \"def time(self):\\r\\n raise NotImplementedError\",\n \"def setTimepoint(self, tp):\\n\\t\\tpass\",\n \"def time(self):\\n return self._begin\",\n \"def t0(self):\\n return self._time_axis.start\",\n \"def get_time(self):\\n start=''\\n end=''\\n time=''\\n times=self.times\\n print(times[self.istep])\\n if self.istep > 0:\\n start=ncEarth.beginstr % times[self.istep].isoformat()\\n\\n\\n if self.istep < len(times)-2:\\n end = ncEarth.endstr % times[self.istep+1].isoformat()\\n\\n if start is not '' or end is not '':\\n time=ncEarth.timestr % {'begin':start,'end':end}\\n\\n return time\",\n \"def oneTimepoint(timepoint):\\n\\tt = []\\n\\tfor vs in timepoint:\\n\\t\\tt.append((timepoint.attrib.get('CollectionTime'), vs[0].text, vs[1].text))\\n\\treturn(t)\",\n \"def start_time(self) -> float:\\r\\n ...\",\n \"def get_time(self) -> float:\\n raise NotImplementedError()\",\n \"def timeofflight(xhat0):\\n\\t\\timport poincare\\n\\t\\t#Find the point on the computed poincare section, closest to the x0\\n\\t\\timin = np.argmin(np.linalg.norm(ps[:,1:5]-xhat0, axis=1))\\n\\t\\t#Take its time of flight as\\n\\t\\tif imin < np.size(ps,0)-1: \\n\\t\\t\\tTapproximate = ps[imin+1,0]-ps[imin,0]\\n\\t\\telse:\\n\\t\\t\\tTapproximate = ps[imin,0]-ps[imin-1,0]\\n\\t\\tprint(\\\"Tapproximate:\\\")\\n\\t\\tprint(Tapproximate)\\n\\t\\t#Integrate for a little bit longer than the approximated integration time:\\n\\t\\tstoptime = 1.2*Tapproximate\\n\\t\\tnumpoints = int(stoptime/0.01)\\n\\t\\t#Integration time array:\\n\\t\\tt = np.linspace(0, stoptime, numpoints)\\n\\t\\txhatphi0 = np.append(xhat0, np.array([0], float))\\n\\t\\txhatsol = twomode.intslice(xhatphi0, t, abserror=1.0e-14, relerror=1.0e-12)\\n\\t\\ttx = np.append(np.array([t], float).transpose(), xhatsol, axis=1)\\n\\t\\t#Compute Poincare section:\\n\\t\\tpsreturn=poincare.computeps(tx, reqv, nhat, 1)\\n\\t\\tprint(\\\"psreturn:\\\")\\n\\t\\tprint(psreturn)\\n\\t\\t#Take the time nearest to the approximated time. This is due to the\\n\\t\\t#fact that the array ps sometimes includes the initial point and sometimes\\n\\t\\t#does not, hence we are not always sure the position of the first return.\\n\\t\\titof = np.argmin(np.abs(psreturn[:,0]-Tapproximate))\\n\\t\\ttof = psreturn[itof,0]\\n\\t\\treturn tof\",\n \"def at(self, t):\\n return self.start + (self.end - self.start) * t\",\n \"def current_time_step(self) -> ts.TimeStep:\\n return self._current_time_step\",\n \"def gettime(self):\\n return self.t\",\n \"def time(self):\\n raise NotImplementedError()\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def current_time(cls) -> float:\",\n \"def get_time(self):\\n return self.get_timed() / 10.0\",\n \"def initialTime(self):\\n return self.params['t0']\",\n \"def startTime(self) -> float:\\n try: return self.times[0]\\n except IndexError: return 0.0\",\n \"def compute_time_step():\\n\\n dt = Hydro.compute_time_step()\\n\\n return dt\",\n \"def time(self):\\n return sum(self._interval) * .5\",\n \"def time(self):\\n return self.time_array\",\n \"def get_point_at(self, t):\\n segment = self.get_segment_for_time(t)\\n return segment.point_at(t)\",\n \"def timeStep(self):\\n return self.params['h']\",\n \"def wall_time(self):\",\n \"def get_time(self):\\n return numpy.linspace(self.header.time_gate_start, \\\\\\n self.header.time_gate_stop, self.num_time_bins())\",\n \"def round_trip_time(self):\\n ...\",\n \"def __call__(self, t):\\n \\n c = c1 = c2 = 0\\n d = d1 = d2 = None\\n while d1==None or d2==None or d<=d2:\\n _t = self.time(c)\\n if _t == None:\\n break\\n else:\\n d = abs(t - _t)\\n if d1 == None or d<d1:\\n c1, d1 = c, d\\n elif d2 == None or d<d2:\\n c2, d2 = c, d\\n c += 1\\n t1, t2 = map(self.time, [c1, c2])\\n v1, v2 = map(self.__getitem__, [c1, c2])\\n # a lo mejor la lista solo contiene un elemento\\n if t1 == t2:\\n return v1\\n else:\\n # si contiene por lo menos dos, pues interpolacion lineal\\n return (v2*(t - t1) - v1*(t - t2))/(t2 - t1)\",\n \"def getPivotPointKeyTime(self, index, view) -> float:\\n ...\",\n \"def get_time(t):\\n return [time.clock()-t[0], time.time()-t[1]]\",\n \"def evaluate(self, time) -> float:\\n ...\",\n \"def range(self):\\n return self.times[0], self.times[-1]\",\n \"def time_return(self):\\n return self.time\",\n \"def get_imeastime(self):\\n return self.itime\",\n \"def time_step(self):\\n return self._time_step\",\n \"def target(self, time, points, dt, num_way):\\n start_index = min(int(time / dt), num_way - 1)\\n end_index = min(start_index + 1, num_way - 1)\\n start_point = points[start_index]\\n end_point = points[end_index]\\n fraction = float(time % dt) / dt\\n return linear_interpolation_two_points(start_point, end_point, fraction).reshape(3)\",\n \"def mapRetime(ti, timelineTime):\\n return ti.sourceIn() + int((timelineTime - ti.timelineIn()) * ti.playbackSpeed())\",\n \"def time(self) -> int:\\n pass\",\n \"def time(self):\\n try:\\n if self.single_date:\\n return self.stime\\n else:\\n return self.stime + (self.etime - self.stime) / 2\\n except TypeError:\\n return None\",\n \"def time_based(t, eta_init, last_eta, d = 0.01):\\n return last_eta/(1+d*t)\",\n \"def get_time_step(self):\\n return self._time_step\",\n \"def _get_half_time(self):\\n return self.__half_time\",\n \"def now(self):\\n return self._startTime + self.timeToOffset(self.currentTime, self._timeScale)\",\n \"def GetTime(self, *args, **kwargs):\\n pass\",\n \"def Tt(s_c, point, system):\\n Tx = tra(s_c, point, system)\\n Tx.get_time()\\n return Tx.time\",\n \"def getTime(self):\\n return self.time\",\n \"def _omori_time(integ, c, p):\\n if p == 1:\\n return c*(exp(integ) - 1)\\n else:\\n return (integ*(1 - p) + c**(1 - p))**(1/(1 - p)) - c\",\n \"def time(self):\\n return self[self.time_columns]\",\n \"def time(self):\\n return self[self.time_columns]\",\n \"def getTime(self) -> float:\\n return self.t\",\n \"def timeRange(self):\\r\\n _times = self.getTimes()\\r\\n return _times[0], _times[-1]\",\n \"def time_slot(self):\\n min_time = self.introduction_time or 0\\n current_time = self.agent.evaluation_context.get_current_time()\\n assert isinstance(current_time, Number)\\n if current_time < min_time:\\n return None\\n num = divmod(current_time - min_time, self.__period)[0] + 1\\n start = min_time + (num - 1) * self.period\\n end = start + self.period\\n return num, start, end\",\n \"def ctime(self): # real signature unknown; restored from __doc__\\r\\n pass\",\n \"def exposuretime(self):\\n _, = self.exposuretimes\\n return _\",\n \"def get_time_info(self):\\n\\n raise NotImplementedError\",\n \"def get_time(self):\\n return self.time_param\",\n \"def getTime(self):\\n return self.step / (self.max_step + int(self.include))\",\n \"def getStartTime(self):\\n raise NotImplementedError\",\n \"def time_function(t):\\n\\n omega = np.pi\\n return np.sin(omega * t) + np.sin(10 * omega * t) + np.sin(20 * omega * t)\",\n \"def get_times(self):\\n raise NotImplementedError(\\\"Abstract method not implemented.\\\")\",\n \"def time_slot(self):\\n pass\",\n \"def __getitem__(self, index: datetime.time) -> float:\\n\\n # If the index is in the profile, return the index.\\n if index in self._profile:\\n return self._profile[index]\\n\\n # If the index is not in the profile, then the closest value needs to be\\n # determined. If there is a tie, this does not matter.\\n delta_t_to_t_map = {\\n (\\n abs(\\n time.hour * 3600\\n + time.minute * 60\\n + time.second\\n - (index.hour * 3600 + index.minute * 60 + index.second)\\n )\\n ): time\\n for time in self._profile\\n }\\n return self._profile[delta_t_to_t_map[min(delta_t_to_t_map)]]\",\n \"def getSimulationTime(self):\\r\\n raise NotImplementedError()\",\n \"def time(self):\\n return Time(self.hour, self.minute, self.second)\",\n \"def calculate_time(ix, xi, wf):\\n wf_len = len(wf)\\n x_time = np.arange(ix, (ix + wf_len * xi), xi)\\n return x_time\",\n \"def T(self, point = -1):\\n return self.solution('T', point)\",\n \"def tend(self):\\n return self.tstart + self.duration\",\n \"def get_time(self):\\n return self.time\",\n \"def getStartTime(self):\\n return _osgAnimation.Vec2LinearSampler_getStartTime(self)\",\n \"def __get_time_span(self):\\n\\n nonzero = self.data[\\\"time\\\"].nonzero()\\n return iso_time.time(self.data[\\\"time\\\"][nonzero[0][0]]), iso_time.time(\\n self.data[\\\"time\\\"][nonzero[0][-1]])\",\n \"def at(self, t):\\r\\n return TimeArray(self[self.index_at(t)], time_unit=self.time_unit)\",\n \"def time(self):\\r\\n return self._idx\",\n \"def endTime(self) -> float:\\n try: return self.times[-1]\\n except IndexError: return 0.0\",\n \"def start_time(self):\\n # TODO: use pd.Timestamp instead\\n return self.time[0].to_pydatetime()\",\n \"def next_change(self, t=None):\\n if t is None:\\n t = self.engine.get_now()\\n t -= self.initTime\\n\\n p = float(self.period) / POINTS_PER_CYCLE\\n t2 = math.floor(t / p) * p + p\\n\\n t2 += self.initTime\\n\\n return t2\",\n \"def time(self):\\n return time(\\n self.hour, self.minute, self.second, self.microsecond, fold=self.fold\\n )\",\n \"def t0(self):\\n return self._t0\",\n \"def get_time(self):\\n return self._ticks\",\n \"def constructTimeLineItem(self):\\n\\t\\treturn\",\n \"def evaluateTime(self, *args):\\n return _osgAnimation.Motion_evaluateTime(self, *args)\",\n \"def __call__ (self, t):\\n #if t <= self.last_t:\\n #raise SpaceTimeContinuumError(\\n #\\\"We're moving back in time! Last t = {}, now = {}\\\".format(\\n #self.last_t, t))\\n\\n #samp = self._sample(t)\\n #self.last_t = t\\n #self.last_samp = samp\\n #return samp\\n pass\",\n \"def getStartTime(self):\\n return _osgAnimation.Vec4LinearSampler_getStartTime(self)\",\n \"def gettime(self):\\n interval, value = _timerfd._timerfd.gettime(self)\\n interval = self._join_time(*interval)\\n value = self._join_time(*value)\\n return interval, value\",\n \"def GetTime(self):\\n return self.hour, self.minute, self.second\",\n \"def getStartTime(self):\\n return _osgAnimation.Vec3LinearSampler_getStartTime(self)\",\n \"def test_time(self):\\r\\n pass\",\n \"def _tv_pointwise(data):\\n return np.maximum(\\n 0,\\n np.ceil(\\n (np.expand_dims(data.meeting_time - data.lag, -1) - np.arange(data.x.shape[0]))\\n / data.lag\\n ),\\n )\",\n \"def min_time(self):\\n #{{{ function to return time of first sample\\n\\n return self.mintime\",\n \"def _ith_point(self, i):\\n if self.start is S.NegativeInfinity:\\n initial = self.stop\\n else:\\n initial = self.start\\n\\n if self.start is S.NegativeInfinity:\\n step = -1\\n else:\\n step = 1\\n\\n return initial + i*step\",\n \"def inter_arrival_times(self):\\n # this function returns arrival times between two subsequent tuples in ms\\n # task mean_inter_arrival_time std_inter_arrival_time\\n if self.inter_arrival_time is None:\\n if self.tuple_arrival is None:\\n self.tuple_arrivals()\\n self.inter_arrival_time = convert_throughput_to_inter_arr_times(self.tuple_arrival)\\n\\n return self.inter_arrival_time\",\n \"def PTS(self):\",\n \"def get_reltriggertimes(self):\\n return np.array(self.trtimes)-self.soundstarttime\",\n \"def time(self):\\n\\t\\treturn self._time\",\n \"def REAL_TIME_ADVANCE(dt):\",\n \"def at(self, t, tol=None):\\r\\n return self.data[..., self.time.index_at(t)]\",\n \"def step(self):\\n\\n e = self.event_queue.get()\\n self.current_time = e.time\\n component = e.component\\n component.output(self.current_time)\\n component.input(self.current_time)\\n component.fire()\\n\\n self.event_queue.put(VirtualTimeScheduler.Event(self.current_time + component.interval, component))\\n\\n return self.current_time\",\n \"def get_time() -> int:\\n return store.time\",\n \"def getSegment(self, t: float, endBehavior: str = 'halt') -> Tuple[int,float]:\\n if len(self.times)==0:\\n raise ValueError(\\\"Empty trajectory\\\")\\n if len(self.times)==1:\\n return (-1,0)\\n if t > self.times[-1]:\\n if endBehavior == 'loop':\\n try:\\n t = t % self.times[-1]\\n except ZeroDivisionError:\\n t = 0\\n else:\\n return (len(self.milestones)-1,0)\\n if t >= self.times[-1]:\\n return (len(self.milestones)-1,0)\\n if t <= self.times[0]:\\n return (-1,0)\\n i = bisect.bisect_right(self.times,t)\\n p=i-1\\n assert i > 0 and i < len(self.times),\\\"Invalid time index \\\"+str(t)+\\\" in \\\"+str(self.times)\\n u=(t-self.times[p])/(self.times[i]-self.times[p])\\n if i==0:\\n if endBehavior == 'loop':\\n t = t + self.times[-1]\\n p = -2\\n u=(t-self.times[p])/(self.times[-1]-self.times[p])\\n else:\\n return (-1,0)\\n assert u >= 0 and u <= 1\\n return (p,u)\",\n \"def get_time_walking(self):\\n return self.time_step_to_enqueue - self.time_entered\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.679934","0.6443112","0.64257336","0.64229566","0.6388925","0.63801783","0.6370203","0.6363844","0.63452727","0.6335522","0.63265383","0.63182783","0.63152707","0.6278807","0.61801505","0.61801505","0.61801505","0.6171835","0.6104696","0.6076395","0.6036604","0.603092","0.6029649","0.5990972","0.5990795","0.59827584","0.5976216","0.5961865","0.594199","0.5936456","0.5935444","0.5932402","0.59293896","0.59293413","0.5924414","0.59177715","0.5911112","0.5904048","0.589973","0.5883483","0.58779603","0.5877914","0.58748597","0.58729553","0.5867333","0.58635885","0.58564943","0.5853735","0.584898","0.58410245","0.58410245","0.5836833","0.58148086","0.581181","0.5806365","0.58059835","0.5799788","0.5791074","0.57721853","0.5768007","0.5753","0.57458824","0.57442605","0.5734192","0.57335484","0.57330894","0.5729656","0.5725458","0.5724946","0.5713531","0.57030916","0.5699016","0.56964445","0.5695903","0.5686287","0.56836575","0.5682945","0.5676177","0.56726706","0.5671211","0.56696343","0.5667257","0.5662354","0.56614304","0.56589943","0.56582904","0.56579876","0.56551176","0.56543016","0.56483454","0.5644313","0.5633681","0.56329614","0.5625423","0.56243485","0.5621892","0.5621597","0.56145895","0.5613262","0.5609079","0.5607369"],"string":"[\n \"0.679934\",\n \"0.6443112\",\n \"0.64257336\",\n \"0.64229566\",\n \"0.6388925\",\n \"0.63801783\",\n \"0.6370203\",\n \"0.6363844\",\n \"0.63452727\",\n \"0.6335522\",\n \"0.63265383\",\n \"0.63182783\",\n \"0.63152707\",\n \"0.6278807\",\n \"0.61801505\",\n \"0.61801505\",\n \"0.61801505\",\n \"0.6171835\",\n \"0.6104696\",\n \"0.6076395\",\n \"0.6036604\",\n \"0.603092\",\n \"0.6029649\",\n \"0.5990972\",\n \"0.5990795\",\n \"0.59827584\",\n \"0.5976216\",\n \"0.5961865\",\n \"0.594199\",\n \"0.5936456\",\n \"0.5935444\",\n \"0.5932402\",\n \"0.59293896\",\n \"0.59293413\",\n \"0.5924414\",\n \"0.59177715\",\n \"0.5911112\",\n \"0.5904048\",\n \"0.589973\",\n \"0.5883483\",\n \"0.58779603\",\n \"0.5877914\",\n \"0.58748597\",\n \"0.58729553\",\n \"0.5867333\",\n \"0.58635885\",\n \"0.58564943\",\n \"0.5853735\",\n \"0.584898\",\n \"0.58410245\",\n \"0.58410245\",\n \"0.5836833\",\n \"0.58148086\",\n \"0.581181\",\n \"0.5806365\",\n \"0.58059835\",\n \"0.5799788\",\n \"0.5791074\",\n \"0.57721853\",\n \"0.5768007\",\n \"0.5753\",\n \"0.57458824\",\n \"0.57442605\",\n \"0.5734192\",\n \"0.57335484\",\n \"0.57330894\",\n \"0.5729656\",\n \"0.5725458\",\n \"0.5724946\",\n \"0.5713531\",\n \"0.57030916\",\n \"0.5699016\",\n \"0.56964445\",\n \"0.5695903\",\n \"0.5686287\",\n \"0.56836575\",\n \"0.5682945\",\n \"0.5676177\",\n \"0.56726706\",\n \"0.5671211\",\n \"0.56696343\",\n \"0.5667257\",\n \"0.5662354\",\n \"0.56614304\",\n \"0.56589943\",\n \"0.56582904\",\n \"0.56579876\",\n \"0.56551176\",\n \"0.56543016\",\n \"0.56483454\",\n \"0.5644313\",\n \"0.5633681\",\n \"0.56329614\",\n \"0.5625423\",\n \"0.56243485\",\n \"0.5621892\",\n \"0.5621597\",\n \"0.56145895\",\n \"0.5613262\",\n \"0.5609079\",\n \"0.5607369\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94990,"cells":{"query":{"kind":"string","value":"A method that reads information from an image"},"document":{"kind":"string","value":"def retrieveImageInfo(self, filename):\t\t \n\t\tassert filename, \"Filename must be defined\"\n\t\tassert os.path.exists(filename), \"File that we're retrieving information \\\n\t\t\t\t\t\t\t\t\t\tfrom (%s) needs to exist, but doesn't.\" % filename\n\t\tself.ext = filename.split(\".\")[-1].lower()\n\t\trdr = self.getReaderByExtension(self.ext)\n\t\t\n\t\tif self.ext == \"bmp\":\n\t\t\trdr.Allow8BitBMPOn()\n\t\trdr.SetFileName(filename)\n\t\tif rdr.IsA(\"vtkExtTIFFReader\"):\n\t\t\trdr.UpdateInformation()\n\t\t\tif rdr.GetNumberOfScalarComponents() == 1:\n\t\t\t\trdr.RawModeOn()\n\n\t\tdata = rdr.GetOutput()\n\t\tdata.Update()\n\t\tself.numberOfComponents = data.GetNumberOfScalarComponents()\n\n\t\tif not self.ctf:\n\t\t\tbd = self.getDataBitDepth(data)\n\t\t\tself.ctf = vtk.vtkColorTransferFunction()\n\t\t\tif bd == 8 or bd == 12:\n\t\t\t\tself.ctf.AddRGBPoint(0, 0, 0, 0)\n\t\t\t\tself.ctf.AddRGBPoint((2 ** bd) - 1, 0, 1, 0)\n\t\t\telse:\n\t\t\t\trange = data.GetScalarRange()\n\t\t\t\tself.ctf.AddRGBPoint(range[0], 0, 0, 0)\n\t\t\t\tself.ctf.AddRGBPoint(range[1], 0, 1, 0)\n\t\t\t\n\t\tself.x, self.y, z = data.GetDimensions()\n\t\tself.dimensions = (self.x, self.y, self.slicesPerTimepoint)\n\t\tif z > 1:\n\t\t\tself.slicesPerTimepoint = z\n\t\t\tself.z = z\n\t\t\tself.dimensions = (self.x, self.y, self.slicesPerTimepoint)\n\t\t\tlib.messenger.send(self, \"update_dimensions\")\n\t\tself.originalDimensions = self.dimensions"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def image_info(img):\n\tprint(img.format)\n\tprint(img.size)\n\tprint(img.mode)","def test_read_image(self):\n pass","def image_info(path):\n global working_img\n working_img = Image.open(path)\n print('=======================================')\n print(f'이미지 파일 이름:{working_img.filename}')\n print(f'이미지 파일 파일 형식:{working_img.format}')\n print(f'이미지 용량:{working_img.size}')\n print(f'이미지 색상모드:{working_img.mode}')\n print(f'이미지 크기:{working_img.width}x{working_img.height}')","def print_image_info(input_image):\n print()\n print(\"Basic Information on image: {}\".format(input_image.filename))\n print(\"Format: {}\".format(input_image.format))\n print(\"Mode: {}\".format(input_image.mode))\n print(\"Size: {}\".format(input_image.size))\n print(\"Width: {}\".format(input_image.width))\n print(\"Height: {}\".format(input_image.height))\n print(\"Palette: {}\".format(input_image.palette))\n print()","def getimage(self):","def get_image_info(path):\n try:\n image = Image.open(path)\n except IOError:\n logger.error(f\"'{path}' is not an image\")\n return\n\n if image.format != \"JPEG\":\n logger.error(f\"'{path}' is not a JPEG\")\n return\n\n info = {\n \"filename\": path,\n \"width\": image.width,\n \"height\": image.height,\n \"fileSize\": os.path.getsize(path),\n \"md5\": md5sum_file(path),\n }\n return info","def getImageInfo(img, header=''):\n if (os.path.exists(img) == False):\n print \"image not found: \", img\n return\n # Assume this is a CASA image\n if (header == ''):\n try:\n print \"imhead\",\n header = imhead(img, mode = 'list') # This will work for most CASA builds\n except:\n print \"imhead\",\n header = imhead(img) # needed to prevent crash in early CASA 4.6 builds (see CAS-8214)\n print \"imhead\",\n header = imhead(img, mode = 'list')\n if (header is None):\n print \"imhead returned NoneType. This image header is not sufficiently standard.\"\n return\n if ('beammajor' in header.keys()):\n bmaj = header['beammajor']\n bmin = header['beamminor']\n bpa = header['beampa']\n elif ('perplanebeams' in header.keys()):\n beammajor = []\n beamminor = []\n beampa = []\n for beamchan in range(header['perplanebeams']['nChannels']):\n beamdict = header['perplanebeams']['*'+str(beamchan)]\n beammajor.append(beamdict['major']['value'])\n beamminor.append(beamdict['minor']['value'])\n beampa.append(beamdict['positionangle']['value'])\n bmaj = np.median(beammajor)\n bmin = np.median(beamminor)\n sinbpa = np.sin(np.radians(np.array(beampa)))\n cosbpa = np.cos(np.radians(np.array(beampa)))\n bpa = np.degrees(np.median(np.arctan2(np.median(sinbpa), np.median(cosbpa))))\n else:\n bmaj = 0\n bmin = 0\n bpa = 0\n naxis1 = header['shape'][0]\n naxis2 = header['shape'][1]\n cdelt1 = header['cdelt1']\n cdelt2 = header['cdelt2']\n if (header['cunit1'].find('rad') >= 0):\n # convert from rad to arcsec\n cdelt1 *= 3600*180/np.pi\n elif (header['cunit1'].find('deg') >= 0):\n # convert from deg to arcsec\n cdelt1 *= 3600\n if (header['cunit2'].find('rad') >= 0):\n cdelt2 *= 3600*180/np.pi\n # convert from rad to arcsec\n elif (header['cunit2'].find('deg') >= 0):\n # convert from deg to arcsec\n cdelt2 *= 3600\n if (type(bmaj) == dict):\n # casa >= 4.1.0 (previously these were floats)\n bmaj = headerToArcsec(bmaj)\n bmin = headerToArcsec(bmin)\n bpa = headerToArcsec(bpa)/3600.\n ghz = 0\n if ('ctype4' in header.keys()):\n if (header['ctype4'] == 'Frequency'):\n imgfreq = header['crval4']\n cdelt = header['cdelt4']\n crpix = header['crpix4']\n npix = header['shape'][3]\n ghz = imgfreq*1e-9\n if (ghz == 0):\n if ('ctype3' in header.keys()):\n if (header['ctype3'] == 'Frequency'):\n imgfreq = header['crval3']\n cdelt = header['cdelt3']\n crpix = header['crpix3']\n npix = header['shape'][2]\n ghz = imgfreq*1e-9\n return([bmaj,bmin,bpa,cdelt1,cdelt2,naxis1,naxis2,ghz], header)","def image_process(image_info):\n path = os.path.join(cfg.IMAGESET, image_info.get(\"index\") + \".jpg\")\n if not os.path.exists(path):\n raise IOError(\"please check your file is not exists: \" + path)\n def load_image(path):\n image = Image.open(path)\n return image\n return load_image(path)","def file_reader(image_file, label_file):\n\n image = im.imread(image_file)\n\n with open(label_file, \"r\") as file:\n label = float(file.read())\n\n return image, label","def read_image(image_path, *args, **kwargs):\n # TODO: Implement the method\n image2 = Image.open(image_path)\n image = num.asarray(image2)\n\n return image","def read_image(self, item):\n assert item['image_dtype'] == 'uint16'\n\n filename = os.path.join(self.home(item['basename']))\n s = open(filename, 'rb').read()\n assert hashlib.md5(s).hexdigest() == item['md5']\n img = np.fromstring(s, dtype=item['image_dtype']).byteswap()\n img = img.reshape(item['image_shape'])\n return img","def read_img(img_path): \n return sitk.GetArrayFromImage(sitk.ReadImage(img_path))","def read_image(path):\n img = misc.imread(path)\n return img","def _GetImageInfo(self,path):\n hd = Header(path, scan=True)\n hdr = hd.hdr\n self.hdr = hdr\n if hdr is None:\n# Either a ref.dat file or it isn't an imaging file.\n if 'ref' in path and 'dat' in path:\n self.refdats[os.path.realpath(path)] = True\n info = {'type':'refdat'}\n return info\n else:\n return None\n elif hdr['filetype'] == 'dicom' and not path.endswith('.yaml'):\n# Write a yaml file to the raw data directory if possible.\n dirname, outfile = self._yaml_filename(path)\n yaml_name = '%s/%s' % (dirname, outfile)\n if not os.path.exists(yaml_name):\n# Create yaml file using dirname,\n# e.g., ../anatomicals/S2_EFGRE3D/s2_efgre3d.yaml\n try:\n hd.write_hdr_to_yaml('%s/%s' % (dirname,outfile))\n except IOError:\n# This is a nonessential function, so ignore exceptions\n# such as access violations.\n pass\n elif hdr['filetype'] == 'dicom' or hdr['filetype'] == 'ge_ifile':\n if not os.path.isdir(path):\n path = os.path.dirname(path)\n shdr = hdr['subhdr']\n nhdr = hdr['native_header']\n self.shdr = shdr\n if 'dti' in shdr.get('PulseSequenceName','').lower() \\\n or 'dti' in nhdr.get('PulseSequenceFile',''):\n psdname = 'dti'\n else:\n psdname = os.path.basename((shdr.get('PulseSequenceName','').strip()).lower())\n info = {'psdname':psdname, \\\n 'acqtime':shdr['AcqTime'], \\\n 'series':int(shdr['SeriesNumber']), \\\n 'plane':hdr['plane'].strip(), \\\n 'type':self.imgtype.get(psdname,None), \\\n 'plane':hdr['plane'], \\\n 'acqtime':shdr['SeriesTime'], \\\n# 'fmapdir':None, \\\n 'refdat':None, \\\n 'imgfile':None, \\\n 'base':None, \\\n 'tdim':int(hdr['tdim']), \\\n 'echo_spacing':None, \\\n 'filetype':'brik', \\\n 'suffix':self.suffix.get(hdr['filetype'], 'brik'), \\\n 'data_filetype':hdr['filetype']}\n if info['type'] == 'localizer':\n# Don't process the localizer.\n return info\n if isinstance(info['acqtime'], int):\n info['acquisition_time'] = time.ctime(info['acqtime'])\n if nhdr.get('ImageFormat',('unknown'))[0] == 'DERIVED' and info['type'] == 'epi':\n# Sometimes screenshots are defined as epis.\n info['type'] = None\n\n# Call the method appropriate to the type of scan in this series.\n stat = apply( self.GetInfoMethods.get(info['type'], self._NoInfo), \\\n [info, path])\n if stat:\n info = {'type':'break'}\n return info\n info['suffix'] = self.suffix.get(info['filetype'], 'brik')\n return info","def process(self, image):","def read_img(components):\n\n img_buf = open(components[0], 'rb').read()\n\n if not img_buf:\n raise Exception('image not read, path=%s' % components[0])\n\n arr = np.fromstring(img_buf, np.uint8)\n img = cv2.imdecode(arr, cv2.IMREAD_COLOR)\n components[1], components[2] = img.shape[:2]\n components[10] = img\n\n return components","def read_image(img_path):\n img = imageio.imread(uri=img_path)\n return img","def load_image(nom):\n print(\"load_image : [\", nom, \"]\")\n fic = gdal.Open(nom)\n print(fic)\n return fic.ReadAsArray(), fic.GetGeoTransform()","def _read_image(self, image_path:str, label:str):\n # Get the full path to the image\n image = \"\"\n if label == \"real\":\n image = os.path.join(self.root, \"real\", image_path)\n else:\n image = os.path.join(self.root, \"fake\", image_path)\n \n # Read the image\n image = cv2.imread(image)\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n\n # Normalize the image\n image = image / 255.0\n\n # Convert the image to floating point to use it as\n # an input to the PyTorch model\n image = image.astype(np.float32)\n\n return image","def image_info(self):\n\n if not self._image_info:\n path_image_info = os.path.join(\n self._path, f\"ImageSet_{self._image['ImageSetID']}.ImageInfo\"\n )\n\n # Make sure the ImageInfo file really exists\n if not os.path.exists(path_image_info):\n self.logger.warning(\"ImageInfo path doesn't exist: %s\", path_image_info)\n return None\n\n self.logger.debug(\"Reading image data from: %s\", path_image_info)\n self._image_info = pinn_to_dict(path_image_info)\n\n return self._image_info","def read_image(path: str):\n return Image.open(path, mode=\"r\")","def read_image(path):\n img = ndimage.imread(path, mode=\"RGB\") \n return img","def open_image_and_meta(image_bytes):\n with MemoryFile(image_bytes) as memfile:\n with memfile.open() as src:\n meta = src.meta\n arr = reshape_as_image(src.read())\n return arr, meta","def read_first_image(file_name):\n pixels = None\n try : # open file_name\n with fits.open(file_name) as fits_blocks:\n block = fits_blocks[0]\n pixels = block.data\n header = block.header\n except IOError:\n print(\"Error while opening/reading file !\")\n exit()\n except FileNotFoundError:\n print(\"Error with file name\")\n exit()\n\n\n return header, pixels","def read_image(img):\n out = Image.open(img)\n return Technicolor(out)","def load(image_path):\n out = None\n\n #####################################\n # START YOUR CODE HERE #\n #####################################\n # Use skimage io.imread\n out = io.imread(image_path)\n ######################################\n # END OF YOUR CODE #\n ######################################\n\n return out","def load_image(self, image_id):\n # Load image\n# print(self.image_info[image_id]['path'])\n image = cv2.imread(self.image_info[image_id]['path'],cv2.IMREAD_GRAYSCALE) \n image = image[:,:, np.newaxis] #Add 1 dimension for grayscale images\n return image","def read_image(filename, representation):\n img = imread(filename)\n img = int2float(img)\n if representation == GS_REP:\n img = rgb2gray(img)\n return img","def get_image_data(self):\n raise NotImplementedError(str(type(self)) + 'does not'\n 'implement get_image.')","def iread(filename, *args, verbose=True, **kwargs):\n\n # determine if file is valid:\n # assert isinstance(filename, str), 'filename must be a string'\n\n\n # TODO read options for image\n # opt = {\n # 'uint8': False,\n # 'single': False,\n # 'double': False,\n # 'grey': False,\n # 'grey_709': False,\n # 'gamma': 'sRGB',\n # 'reduce': 1.0,\n # 'roi': None\n # }\n\n if isinstance(filename, str) and (filename.startswith(\"http://\") or filename.startswith(\"https://\")):\n # reading from a URL\n\n resp = urllib.request.urlopen(filename)\n array = np.asarray(bytearray(resp.read()), dtype=\"uint8\")\n image = cv.imdecode(array, -1)\n print(image.shape)\n return (image, filename)\n\n elif isinstance(filename, (str, Path)):\n # reading from a file\n\n path = Path(filename).expanduser()\n\n if any([c in \"?*\" for c in str(path)]):\n # contains wildcard characters, glob it\n # recurse and return a list\n # https://stackoverflow.com/questions/51108256/how-to-take-a-pathname-string-with-wildcards-and-resolve-the-glob-with-pathlib\n \n parts = path.parts[1:] if path.is_absolute() else path.parts\n p = Path(path.root).glob(str(Path(\"\").joinpath(*parts)))\n pathlist = list(p)\n\n if len(pathlist) == 0 and not path.is_absolute():\n # look in the toolbox image folder\n path = Path(__file__).parent / \"images\" / path\n parts = path.parts[1:] if path.is_absolute() else path.parts\n p = Path(path.root).glob(str(Path(\"\").joinpath(*parts)))\n pathlist = list(p)\n \n if len(pathlist) == 0:\n raise ValueError(\"can't expand wildcard\")\n\n imlist = []\n pathlist.sort()\n for p in pathlist:\n imlist.append(iread(p, **kwargs))\n return imlist\n\n else:\n # read single file\n\n if not path.exists():\n if path.is_absolute():\n raise ValueError(f\"file {filename} does not exist\")\n # file doesn't exist\n # see if it matches the supplied images\n path = Path(__file__).parent / \"images\" / path\n\n if not path.exists():\n raise ValueError(f\"file {filename} does not exist, and not found in supplied images\")\n\n # read the image\n # TODO not sure the following will work on Windows\n im = cv.imread(path.as_posix(), **kwargs) # default read-in as BGR\n\n if im is None:\n # TODO check ValueError\n raise ValueError(f\"Could not read {filename}\")\n\n return (im, str(path))\n\n elif islistof(filename, (str, Path)):\n # list of filenames or URLs\n # assume none of these are wildcards, TODO should check\n out = []\n for file in filename:\n out.append(iread(file, *args))\n return out\n else:\n raise ValueError(filename, 'invalid filename')","def _get_image_info(\n image_id: int,\n width: int,\n height: int,\n file_name: str,\n license_id=1,\n flickr_url=\"\",\n coco_url=\"\",\n date_captured=datetime.datetime.utcnow().isoformat(' ')):\n image_info = {\n \"id\": image_id,\n \"width\": width,\n \"height\": height,\n \"file_name\": file_name,\n \"license\": license_id,\n \"flickr_url\": flickr_url,\n \"coco_url\": coco_url,\n \"date_captured\": date_captured,\n }\n\n return image_info","def get_image(inf):\n try:\n x, y = Image.open(inf).size\n except FileNotFoundError:\n print(\"Error: {} file not found.\".format(inf))\n sys.exit(1)\n\n pixels = list(Image.open(inf).getdata())\n return x, y, pixels","def readImage(self, path, tt=1):\n return cv2.imread( path, tt)","def test_read(self):\n for line in TESTIMAGES.split(\"\\n\"):\n vals = line.split()\n name = vals[0]\n dim1, dim2 = [int(x) for x in vals[1:3]]\n mini, maxi, mean, stddev = [float(x) for x in vals[3:]]\n obj = marccdimage()\n obj.read(self.fn[name])\n self.assertAlmostEqual(mini, obj.getmin(), 2, \"getmin\")\n self.assertAlmostEqual(maxi, obj.getmax(), 2, \"getmax\")\n self.assertAlmostEqual(mean, obj.getmean(), 2, \"getmean\")\n self.assertAlmostEqual(stddev, obj.getstddev(), 2, \"getstddev\")\n self.assertEqual(dim1, obj.dim1, \"dim1\")\n self.assertEqual(dim2, obj.dim2, \"dim2\")","def read_image(image_path):\n if not os.path.exists(image_path):\n raise IOError('File does not exist: %s' % image_path)\n else:\n return Image.open(image_path)","def read_img(img_path):\n return sitk.GetArrayFromImage(sitk.ReadImage(img_path))","def _process_image(filename, coder):\n # Read the image file.\n with tf.gfile.FastGFile(filename, 'rb') as f:\n image_data = f.read()\n \n # Convert any PNG to JPEG's for consistency.\n if _is_png(filename):\n print('Converting PNG to JPEG for %s' % filename)\n image_data = coder.png_to_jpeg(image_data)\n # Decode the RGB JPEG.\n image = coder.decode_jpeg(image_data)\n\n # Check that image converted to RGB\n assert len(image.shape) == 3\n height = image.shape[0]\n width = image.shape[1]\n assert image.shape[2] == 3\n\n return image_data, height, width","def read_image(filename):\n img = Image.open(filename)\n im = np.array(img)\n return im","def read_image(image_path):\n im = Image.open(image_path, 'r')\n return np.array(im)","def img_read(name):\n\n img = cv2.imread(name)\n\n return img","def do_info (self, line) :\n\t\tprint\n\t\tprint get_info_string( self.__image )\n\t\tprint","def get_input(path):\n img = imread(path)\n return img","def build_img_info(img_root):\n imgs = []\n feats = []\n K = []\n for i, name in enumerate(os.listdir(img_root)):\n if '.jpg' in name or '.JPG' in name:\n path = os.path.join(img_root, name)\n img = cv2.imread(path)\n imgs.append(img)\n feature_process = FeatureProcess(img)\n kpt, des = feature_process.extract_features()\n photo_info = PhotoExifInfo(path)\n photo_info.get_tags()\n K.append(photo_info.get_intrinsic_matrix())\n A = photo_info.get_area()\n D = photo_info.get_diam()\n feats.append({'kpt': kpt, 'des': des, 'A': A, 'D': D})\n return imgs, feats, K","def imread(fname):\n try:\n fp = open(fname, 'rb')\n im = Image.open(fp)\n except:\n sys.stderr.write('IOException: Invalid input type on '+fname+'\\n')\n sys.exit(1)\n else:\n if im.format not in FILETYPES:\n sys.stderr.write('IOException: Invalid image type\\n')\n sys.exit(1)\n \n fa = np.array(im.convert('F'))\n im = im.convert('RGB')\n wa = np.array(im)\n \n fp.close()\n\n return fa, wa","def fetchInfo(self, path):\n\n\n img = self.getImageObject(path)\n\n if isinstance(img, ImageFile):\n return img.size\n else:\n return [img.width, img.height]","def _getImage(self, img):\n\n # lazily fill in some attributes\n if not 'local_file_path' in img:\n img['local_file_path'] = os.path.join(self.image_root, img['filename'])\n if not 'feat' in img: # also fill in the features\n # NOTE: imgid is an integer, and it indexes into features\n fn = os.path.basename(img['filename'])\n return img","def read_img(img_path):\n img_list=[]\n print('image loading...')\n for _,_,files in os.walk(img_path):\n for f in files:\n if f.find('.dcm')>=0:\n tmp_img=dicom.dcmread(os.path.join(img_path,f))\n tmp_img=tmp_img.pixel_array#[0::2,0::2]\n img_list.append(tmp_img)\n img_data=np.array(img_list)\n print('done')\n return img_data","def __read_image(self, filename):\n self.image = cv2.imread(filename)\n self.image = cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB)\n self.im_copy = self.image.copy()\n self.height, self.width = self.image.shape[:2]\n self.debug = 0","def process_image(self):\n pass","def get_raw_img(image_name):\n # IMREAD_COLOR ignores transparency (!)\n return cv2.imread(image_name, cv2.IMREAD_COLOR)","def Read(image_path):\n # use cv2.imread() to read an images.\n # syntax : cv2.imread(filename, flag=None)\n return cv2.imread(image_path, 0)","def image_data_info(page):\n xObject = page['/Resources']['/XObject'].getObject()\n\n for obj_key in xObject:\n obj = xObject[obj_key]\n if obj['/Subtype'] == '/Image':\n width, height = (obj['/Width'], obj['/Height'])\n num_bytes = len(obj._data)\n density = num_bytes * 1.0 / (width * height)\n return {'width': width, 'height': height, 'size': num_bytes, 'density': density}\n\n return None","def get_img_info(self, idx):\n\n image = self.get_img(idx)\n img_height = image.size[0]\n img_width = image.size[1]\n\n return {\"height\": img_height, \"width\": img_width}","def read_image(fileame, representation):\n validate_representation(representation)\n\n im = imread(fileame)\n if representation == 1 and is_rgb(im):\n # We should convert from Grayscale to RGB\n im = rgb2gray(im)\n return im.astype(np.float32)\n\n return normlized_image(im)","def read_img(img_id, train_or_test, size):\n img = image.load_img(join(data_dir, train_or_test, img_id + '.jpg'), target_size=size)\n # img = image.img_to_array(img)\n return img","def read_img(img_path:str) -> object:\n img = cv2.imread(img_path)\n return img","def load_image(self, image_id):\n # Load image\n path = self.image_info[image_id]['path']\n if path.endswith(\".png\" or \".jpg\"):\n image = skimage.io.imread(path)\n elif path.endswith(\".dcm\"):\n ds = pydicom.read_file(path)\n image = ds.pixel_array\n # If grayscale. Convert to RGB for consistency.\n if image.ndim != 3:\n image = skimage.color.gray2rgb(image)\n # If has an alpha channel, remove it for consistency\n if image.shape[-1] == 4:\n image = image[..., :3]\n return image","def fitsread(imgname, header = False):\n try:\n if header:\n img_data, header = pyfits.getdata(imgname, ignore_missing_end = True, header = True)\n return img_data, header\n else:\n img_data = pyfits.getdata(imgname, ignore_missing_end = True)\n return img_data\n except IOError:\n print \"FITSREAD: Unable to open FITS image %s\" %imgname\n \n return","def read_image(image_file_path: str):\n\n pixels = numpy.array(Image.open(image_file_path))\n\n return pixels","def read_image(self, image):\n if image not in self.content:\n img = cv2.imread(image)\n img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n img = cv2.copyMakeBorder(img, 5, 5, 5, 5, cv2.BORDER_CONSTANT)\n text = pytesseract.image_to_string(img).lower()\n self.content[image] = text\n return text\n return self.content[image]","def process_image(file_path):\n img_array = io.imread(file_path)\n detections, shapes, descriptors = detect_faces(person_database,img_array)\n\n names = []\n\n for desc in descriptors:\n name = find_match(person_database, desc)\n names.append(name)\n\n return pic_array, names, detections, shapes, descriptors","def read_image(self, filePath):\n if filePath.endswith(\".dcm\"):\n image = sitk.ReadImage(filePath)\n image = sitk.GetArrayFromImage(image).astype(\"int16\")\n image = np.expand_dims(image[0,:,:], -1)\n elif filePath.endswith(\".png\"):\n image = cv2.imread(filePath)\n image = np.array(image, dtype = \"int16\")\n elif filePath.endswith(\".mha\"):\n image = sitk.ReadImage(filePath)\n image = sitk.GetArrayFromImage(image).astype(\"int16\")\n image = np.transpose(image,(1,2,0))\n return image","def read(self):\n with self.lock:\n return self.image","def imread(path):\n with open(path, 'rb') as f:\n with PIL.Image.open(f) as img:\n return img.convert('RGB')","def open_image(infile):\n with fits.open(infile) as f:\n header = f[0].header\n data = f[0].data\n if data.ndim == 2:\n # NAXIS=2: [Y, X]\n image = data\n elif data.ndim == 3 and data.shape[0] == 1:\n # NAXIS=3: [FREQ=1, Y, X]\n image = data[0, :, :]\n elif data.ndim == 4 and data.shape[0] == 1 and data.shape[1] == 1:\n # NAXIS=4: [STOKES=1, FREQ=1, Y, X]\n image = data[0, 0, :, :]\n else:\n raise ValueError(\"Slice '{0}' has invalid dimensions: {1}\".format(\n infile, data.shape))\n return (header, image)","def process_image(im):\r\n h, _, _ = im.shape\r\n im_gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)\r\n \r\n # Divide the picture into 3 regions\r\n l1 = int(0.65*h)\r\n l2 = int(0.77*h)\r\n im1 = im_gray[:l1,:]\r\n im2 = im_gray[l1+1:l2,:]\r\n im3 = im_gray[l2+1:,:]\r\n \r\n # Extract 4 pictures\r\n pics = extract_4_pics(im, im1)\r\n \r\n # Extract the word size\r\n word_size = extract_word_size(im2)\r\n \r\n # Extract the letters\r\n letters = extract_letters(im3)\r\n \r\n print 'word size =', word_size\r\n print 'letters =', letters\r\n for i, pic in enumerate(pics):\r\n imsave(str(i) + '.png', pic)\r\n\r\n return word_size, letters, pics","def read_image(path):\n reader = sitk.ImageSeriesReader()\n dicom_filenames = reader.GetGDCMSeriesFileNames(path)\n reader.SetFileNames(dicom_filenames)\n reader.LoadPrivateTagsOn()\n img = reader.Execute()\n img.SetOrigin((0, 0, 0))\n return img","def read_image(path):\n\n image = cv2.imread(path)\n return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)","def read_image(filename, representation):\n\n color_flag = True #if RGB image\n image = imread(filename)\n\n float_image = image.astype(np.float64)\n\n if not np.all(image <= 1):\n float_image /= NORMALIZE #Normalized to range [0,1]\n\n if len(float_image.shape) != 3 : #Checks if RGB or Grayscale\n color_flag = False\n\n if color_flag and representation == 1 : #Checks if need RGB to Gray\n return skimage.color.rgb2gray(float_image)\n\n # Same coloring already\n return float_image","def load_image(self, image_index):\n\t\t\timage_info = self.coco.loadImgs(self.image_ids[image_index])[0]\n\t\t\tpath = os.path.join(self.data_dir, 'images', self.set_name, image_info['file_name'])\n\t\t\treturn read_image_bgr(path)","def read_image(image_path: str):\n\treturn cv.imread(image_path, cv.IMREAD_UNCHANGED)","def generate_image_info(image):\n image = ee.Image(image)\n image_vis = image.visualize(**{\n 'min': image_min,\n 'max': image_max,\n 'palette': image_palette\n })\n\n print(image_min, image_max)\n\n if 'hillshade' in r and r['hillshade']:\n image_vis = hillshade(image_vis,\n image.subtract(image_min).divide(ee.Image.constant(image_max).subtract(image_min)),\n True)\n\n m = image_vis.getMapId()\n\n mapid = m.get('mapid')\n token = m.get('token')\n\n url = 'https://earthengine.googleapis.com/map/{mapid}/{{z}}/{{x}}/{{y}}?token={token}'.format(\n mapid=mapid,\n token=token\n )\n\n result = {\n 'mapid': mapid,\n 'token': token,\n 'url': url\n }\n return result","def read_images(self, img_name, label_name):\n image_string = tf.read_file(img_name)\n image_decoded = tf.image.decode_jpeg(image_string, channels=3)\n label_string = tf.read_file(label_name)\n label_decoded = tf.image.decode_jpeg(label_string, channels=1)\n return image_decoded, label_decoded","def imread(fname):\r\n return skimage.io.imread(fname)","def read_image(image_path):\n return np.array(load_img(image_path, color_mode='grayscale')) / 255","def read_map_file(path):\r\n with open(path) as f:\r\n dir_name = os.path.dirname(path)\r\n img = cv2.imread(dir_name + '/' + f.readline().strip())\r\n assert img.shape[0] > 0 and img.shape[1] > 0, 'Can not open image file'\r\n meter_per_pixel = float(f.readline().strip())\r\n ori_str = f.readline().strip().split()\r\n origin = np.array([int(ori_str[0]), int(ori_str[1])])\r\n init_heading = float(ori_str[2])\r\n return img, meter_per_pixel, origin, init_heading","def get_image(image_path):\r\n image = Image.open(image_path, 'r')\r\n width, height = image.size\r\n pixel_values = list(image.getdata())\r\n if image.mode == 'RGB':\r\n channels = 3\r\n elif image.mode == 'L':\r\n channels = 1\r\n else:\r\n print(\"Unknown mode: %s\" % image.mode)\r\n return None\r\n pixel_values = np.array(pixel_values).reshape((1,width, height, channels))\r\n # print(pixel_values.shape)\r\n return pixel_values","def read_image(filename, representation):\n image = scipy.misc.imread(filename)\n if int(representation) == 1:\n image = rgb2gray(image)\n return img_as_float(image)","def __read_img_file(filename, label):\n image = cv2.cvtColor(cv2.imread(filename), cv2.COLOR_BGR2RGB)\n height, width, _ = image.shape\n image = cv2.resize(image, (img_size, img_size))\n # A label is consist of [y1, x1, y2, x2, class_idx]\n label = np.reshape(label, (-1, 5))\n rel_bboxes = label[..., 0:4] / np.array([height, width, height, width], np.float32)\n label = np.concatenate([rel_bboxes, np.expand_dims(label[..., -1], 1)], axis=-1)\n return image, label","def input_image():\r\n im = cv2.imread('im7.png')\r\n return im","def getImage(self, imageName):\n if imageName in self._imageDictionary:\n return self._imageDictionary[imageName]\n else:\n print(str(imageName) + \" is not in the dictionary\")","def read_image(img_path):\n got_img = False\n if not osp.exists(img_path):\n raise IOError(\"{} does not exist\".format(img_path))\n while not got_img:\n try:\n img = Image.open(img_path).convert('RGB')\n got_img = True\n except IOError:\n from ipdb import set_trace; set_trace()\n print(\"IOError incurred when reading '{}'. Will redo. Don't worry. Just chill.\".format(img_path))\n pass\n return img","def generate_image_info(im, params):\n im = ee.Image(im)\n\n # some images are scaled to a factor of 10.\n if params.get('scale') == 'log':\n im = im.log10()\n\n im = im.sldStyle(params.get('sld_style'))\n\n m = im.getMapId()\n\n mapid = m.get('mapid')\n token = m.get('token')\n\n url = 'https://earthengine.googleapis.com/map/{mapid}/{{z}}/{{x}}/{{y}}?token={token}'.format(\n mapid=mapid,\n token=token\n )\n\n result = {\n 'mapid': mapid,\n 'token': token,\n 'url': url\n }\n return result","def parse_image_meta(meta):\n image_id = meta[:, 0]\n image_shape = meta[:, 1:4]\n window = meta[:, 4:8] # (x1, y1, x2, y2) window of image in in pixels\n active_class_ids = meta[:, 8:]\n return image_id, image_shape, window, active_class_ids","def get_image_data (file_path, metadata_required):\n lookup = ImageLookup()\n return lookup.lookup_by_filename(file_path, metadata_required=False)","def __read_image(self, path):\n path = 'data/' + path\n image = cv2.imread(path)\n\n # Convert greyscale image to BGR\n if image.shape[-1] == 1:\n image = np.dstack([image, image, image])\n\n # Convert BGR image to RGB image\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n\n return image","def extract_exif_data(self, path_img):\n try:\n img = PIL.Image.open(path_img)\n self.exif = {PIL.ExifTags.TAGS[k]: v\n for k, v in img._getexif().items()\n if k in PIL.ExifTags.TAGS}\n if 'GPSInfo' in self.exif.keys():\n latitude = str(self.getCoordinate(self.exif['GPSInfo'][2], self.exif['GPSInfo'][1]))\n longitude = str(self.getCoordinate(self.exif['GPSInfo'][4], self.exif['GPSInfo'][3]))\n self.exif['GPSInfo'] = \"https://www.google.com/maps/search/?api=1&query=\" + str(latitude) + \",\" + str(\n longitude)\n return self.exif\n except:\n return None","def readImg(filename, h1, h2, w1, w2):\n img = cv2.imread(filename, 1)\n # plt.figure()\n # plt.imshow(img)\n img = img[h1:h2, w1:w2]\n return img","def read_image(filename, representation):\n im = imread(filename)\n if representation == GS_REP:\n im = rgb2gray(im)\n im = np.divide(im, MAX_VALUE - 1)\n return im","def read_image(img_path):\n got_img = False\n if not osp.exists(img_path):\n raise IOError(\"{} does not exist\".format(img_path))\n while not got_img:\n try:\n img = Image.open(img_path).convert('RGB')\n got_img = True\n except IOError:\n print(\"IOError incurred when reading '{}'. Will redo. Don't worry. Just chill.\".format(img_path))\n pass\n return img","def getimg(filename):\n return np.asarray(Image.open('imgdb/'+filename))","def read_img(img_id, data_dir, train_or_test, size):\n img = image.load_img(os.path.join(data_dir, train_or_test, '%s.jpg' % img_id), target_size=size)\n img = image.img_to_array(img)\n return img","def facts(url_file_stream_or_string):\n source = imagefacts.open_resource._open_resource(url_file_stream_or_string, _handle_url)\n data = source.read()\n return imagefacts.getimageinfo.getImageInfo(data)","def extract(self, source):\n\t\tp = Parser()\n\t\tf = open_pds(source)\n\t\tif self.log: self.log.debug(\"Parsing '%s'\" % (source))\n\t\tself.labels = p.parse(f)\n\t\tif self.log: self.log.debug(\"Found %d labels\" % (len(self.labels)))\n\t\tif self._check_image_is_supported():\n\t\t\tif self.log: self.log.debug(\"Image in '%s' is supported\" % (source))\n\t\t\tdim = self._get_image_dimensions()\n\t\t\tloc = self._get_image_location()\n\t\t\timageSampleBits = int(self.labels['IMAGE']['SAMPLE_BITS'])\n\t\t\timageSampleType = self.labels['IMAGE']['SAMPLE_TYPE']\n\t\t\tmd5Checksum = self._get_image_checksum()\n\t\t\tif self.log: self.log.debug(\"Image dimensions should be %s\" % (str(dim)))\n\t\t\tif self.log: self.log.debug(\"Seeking to image data at %d\" % (loc))\n\t\t\tf.seek(loc)\n\t\t\tif imageSampleBits == 8:\n\t\t\t\treadSize = dim[0] * dim[1]\n\t\t\telif imageSampleBits == 16:\n\t\t\t\treadSize = dim[0] * dim[1] * 2\n\t\t\tprint readSize\n\t\t\tif self.log: self.log.debug(\"Seek successful, reading data (%s)\" % (readSize))\n\t\t\t# rawImageData = f.readline()\n\t\t\t# f.seek(-int(self.labels[\"RECORD_BYTES\"]), os.SEEK_CUR)\n\t\t\trawImageData = f.read(readSize)\n\t\t\tif md5Checksum:\n\t\t\t\trawImageChecksum = hashlib.md5(rawImageData).hexdigest()\n\t\t\t\tchecksumVerificationPassed = rawImageChecksum == md5Checksum and True or False\n\t\t\t\tif not checksumVerificationPassed:\n\t\t\t\t\tif self.log: self.log.debug(\"Secure hash verification failed\")\n\t\t\t\t\tif self.raisesChecksumError:\n\t\t\t\t\t\terrorMessage = \"Verification failed! Expected '%s' but got '%s'.\" % (md5Checksum, rawImageChecksum)\n\t\t\t\t\t\traise ChecksumError, errorMessage\n\t\t\t\telse:\n\t\t\t\t\tif self.log: self.log.debug(\"Secure hash verification passed\")\n\t\t\tif self.log: self.log.debug(\"Read successful (len: %d), creating Image object\" % (len(rawImageData)))\n\t\t\t# The frombuffer defaults may change in a future release;\n\t\t\t# for portability, change the call to read:\n\t\t\t# frombuffer(mode, size, data, 'raw', mode, 0, 1).\n\t\t\tif (imageSampleBits == 16) and imageSampleType == ('MSB_INTEGER'):\n\t\t\t\t#img = Image.frombuffer('I', dim, rawImageData, 'raw', 'I;16BS', 0, 1)\n\t\t\t\timg = Image.frombuffer('F', dim, rawImageData, 'raw', 'F;16B', 0, 1)\n\t\t\t\timg = ImageMath.eval(\"convert(a/16.0, 'L')\", a=img)\n\t\t\telse:\n\t\t\t\timg = Image.frombuffer('L', dim, rawImageData, 'raw', 'L', 0, 1)\n\t\t\tif self.log:\n\t\t\t\tself.log.debug(\"Image result: %s\" % (str(img)))\n\t\t\t\tself.log.debug(\"Image info: %s\" % (str(img.info)))\n\t\t\t\tself.log.debug(\"Image mode: %s\" % (str(img.mode)))\n\t\t\t\tself.log.debug(\"Image size: %s\" % (str(img.size)))\n\t\telse:\n\t\t\tif self.log: self.log.error(\"Image is not supported '%s'\" % (source))\n\t\t\timg = None\n\t\tf.close()\n\n\t\treturn img, self.labels","def input(self):\n\t\treturn self.image","def load_image(self, img_name):\n img_data = cv2.imread(img_name, 0)\n return img_data","def readImage(imageName, flags=cv2.IMREAD_GRAYSCALE):\r\n if imageName.__class__ != \"\".__class__:\r\n print(\"ERROR - readImage: Input type must be a string (image name). Was: \", imageName.__class__)\r\n return None\r\n\r\n # cv2 loads an image in BGR format. Here we have a default value used to load it in grayscale mode\r\n image = cv2.imread(imageName, flags)\r\n return image","def get_image_params(image_path):\n image = cv2.imread(image_path)\n\n return image, image.shape","def _open_image(self, path):\n return cv.imread(path, 1)\n # .astype(float)","def load_image(filename):\n with open(filename, 'rb') as img_handle:\n img = Image.open(img_handle)\n img_data = img.getdata()\n if img.mode.startswith('RGB'):\n pixels = [round(.299 * p[0] + .587 * p[1] + .114 * p[2])\n for p in img_data]\n elif img.mode == 'LA':\n pixels = [p[0] for p in img_data]\n elif img.mode == 'L':\n pixels = list(img_data)\n else:\n raise ValueError('Unsupported image mode: %r' % img.mode)\n w, h = img.size\n return {'height': h, 'width': w, 'pixels': pixels}"],"string":"[\n \"def image_info(img):\\n\\tprint(img.format)\\n\\tprint(img.size)\\n\\tprint(img.mode)\",\n \"def test_read_image(self):\\n pass\",\n \"def image_info(path):\\n global working_img\\n working_img = Image.open(path)\\n print('=======================================')\\n print(f'이미지 파일 이름:{working_img.filename}')\\n print(f'이미지 파일 파일 형식:{working_img.format}')\\n print(f'이미지 용량:{working_img.size}')\\n print(f'이미지 색상모드:{working_img.mode}')\\n print(f'이미지 크기:{working_img.width}x{working_img.height}')\",\n \"def print_image_info(input_image):\\n print()\\n print(\\\"Basic Information on image: {}\\\".format(input_image.filename))\\n print(\\\"Format: {}\\\".format(input_image.format))\\n print(\\\"Mode: {}\\\".format(input_image.mode))\\n print(\\\"Size: {}\\\".format(input_image.size))\\n print(\\\"Width: {}\\\".format(input_image.width))\\n print(\\\"Height: {}\\\".format(input_image.height))\\n print(\\\"Palette: {}\\\".format(input_image.palette))\\n print()\",\n \"def getimage(self):\",\n \"def get_image_info(path):\\n try:\\n image = Image.open(path)\\n except IOError:\\n logger.error(f\\\"'{path}' is not an image\\\")\\n return\\n\\n if image.format != \\\"JPEG\\\":\\n logger.error(f\\\"'{path}' is not a JPEG\\\")\\n return\\n\\n info = {\\n \\\"filename\\\": path,\\n \\\"width\\\": image.width,\\n \\\"height\\\": image.height,\\n \\\"fileSize\\\": os.path.getsize(path),\\n \\\"md5\\\": md5sum_file(path),\\n }\\n return info\",\n \"def getImageInfo(img, header=''):\\n if (os.path.exists(img) == False):\\n print \\\"image not found: \\\", img\\n return\\n # Assume this is a CASA image\\n if (header == ''):\\n try:\\n print \\\"imhead\\\",\\n header = imhead(img, mode = 'list') # This will work for most CASA builds\\n except:\\n print \\\"imhead\\\",\\n header = imhead(img) # needed to prevent crash in early CASA 4.6 builds (see CAS-8214)\\n print \\\"imhead\\\",\\n header = imhead(img, mode = 'list')\\n if (header is None):\\n print \\\"imhead returned NoneType. This image header is not sufficiently standard.\\\"\\n return\\n if ('beammajor' in header.keys()):\\n bmaj = header['beammajor']\\n bmin = header['beamminor']\\n bpa = header['beampa']\\n elif ('perplanebeams' in header.keys()):\\n beammajor = []\\n beamminor = []\\n beampa = []\\n for beamchan in range(header['perplanebeams']['nChannels']):\\n beamdict = header['perplanebeams']['*'+str(beamchan)]\\n beammajor.append(beamdict['major']['value'])\\n beamminor.append(beamdict['minor']['value'])\\n beampa.append(beamdict['positionangle']['value'])\\n bmaj = np.median(beammajor)\\n bmin = np.median(beamminor)\\n sinbpa = np.sin(np.radians(np.array(beampa)))\\n cosbpa = np.cos(np.radians(np.array(beampa)))\\n bpa = np.degrees(np.median(np.arctan2(np.median(sinbpa), np.median(cosbpa))))\\n else:\\n bmaj = 0\\n bmin = 0\\n bpa = 0\\n naxis1 = header['shape'][0]\\n naxis2 = header['shape'][1]\\n cdelt1 = header['cdelt1']\\n cdelt2 = header['cdelt2']\\n if (header['cunit1'].find('rad') >= 0):\\n # convert from rad to arcsec\\n cdelt1 *= 3600*180/np.pi\\n elif (header['cunit1'].find('deg') >= 0):\\n # convert from deg to arcsec\\n cdelt1 *= 3600\\n if (header['cunit2'].find('rad') >= 0):\\n cdelt2 *= 3600*180/np.pi\\n # convert from rad to arcsec\\n elif (header['cunit2'].find('deg') >= 0):\\n # convert from deg to arcsec\\n cdelt2 *= 3600\\n if (type(bmaj) == dict):\\n # casa >= 4.1.0 (previously these were floats)\\n bmaj = headerToArcsec(bmaj)\\n bmin = headerToArcsec(bmin)\\n bpa = headerToArcsec(bpa)/3600.\\n ghz = 0\\n if ('ctype4' in header.keys()):\\n if (header['ctype4'] == 'Frequency'):\\n imgfreq = header['crval4']\\n cdelt = header['cdelt4']\\n crpix = header['crpix4']\\n npix = header['shape'][3]\\n ghz = imgfreq*1e-9\\n if (ghz == 0):\\n if ('ctype3' in header.keys()):\\n if (header['ctype3'] == 'Frequency'):\\n imgfreq = header['crval3']\\n cdelt = header['cdelt3']\\n crpix = header['crpix3']\\n npix = header['shape'][2]\\n ghz = imgfreq*1e-9\\n return([bmaj,bmin,bpa,cdelt1,cdelt2,naxis1,naxis2,ghz], header)\",\n \"def image_process(image_info):\\n path = os.path.join(cfg.IMAGESET, image_info.get(\\\"index\\\") + \\\".jpg\\\")\\n if not os.path.exists(path):\\n raise IOError(\\\"please check your file is not exists: \\\" + path)\\n def load_image(path):\\n image = Image.open(path)\\n return image\\n return load_image(path)\",\n \"def file_reader(image_file, label_file):\\n\\n image = im.imread(image_file)\\n\\n with open(label_file, \\\"r\\\") as file:\\n label = float(file.read())\\n\\n return image, label\",\n \"def read_image(image_path, *args, **kwargs):\\n # TODO: Implement the method\\n image2 = Image.open(image_path)\\n image = num.asarray(image2)\\n\\n return image\",\n \"def read_image(self, item):\\n assert item['image_dtype'] == 'uint16'\\n\\n filename = os.path.join(self.home(item['basename']))\\n s = open(filename, 'rb').read()\\n assert hashlib.md5(s).hexdigest() == item['md5']\\n img = np.fromstring(s, dtype=item['image_dtype']).byteswap()\\n img = img.reshape(item['image_shape'])\\n return img\",\n \"def read_img(img_path): \\n return sitk.GetArrayFromImage(sitk.ReadImage(img_path))\",\n \"def read_image(path):\\n img = misc.imread(path)\\n return img\",\n \"def _GetImageInfo(self,path):\\n hd = Header(path, scan=True)\\n hdr = hd.hdr\\n self.hdr = hdr\\n if hdr is None:\\n# Either a ref.dat file or it isn't an imaging file.\\n if 'ref' in path and 'dat' in path:\\n self.refdats[os.path.realpath(path)] = True\\n info = {'type':'refdat'}\\n return info\\n else:\\n return None\\n elif hdr['filetype'] == 'dicom' and not path.endswith('.yaml'):\\n# Write a yaml file to the raw data directory if possible.\\n dirname, outfile = self._yaml_filename(path)\\n yaml_name = '%s/%s' % (dirname, outfile)\\n if not os.path.exists(yaml_name):\\n# Create yaml file using dirname,\\n# e.g., ../anatomicals/S2_EFGRE3D/s2_efgre3d.yaml\\n try:\\n hd.write_hdr_to_yaml('%s/%s' % (dirname,outfile))\\n except IOError:\\n# This is a nonessential function, so ignore exceptions\\n# such as access violations.\\n pass\\n elif hdr['filetype'] == 'dicom' or hdr['filetype'] == 'ge_ifile':\\n if not os.path.isdir(path):\\n path = os.path.dirname(path)\\n shdr = hdr['subhdr']\\n nhdr = hdr['native_header']\\n self.shdr = shdr\\n if 'dti' in shdr.get('PulseSequenceName','').lower() \\\\\\n or 'dti' in nhdr.get('PulseSequenceFile',''):\\n psdname = 'dti'\\n else:\\n psdname = os.path.basename((shdr.get('PulseSequenceName','').strip()).lower())\\n info = {'psdname':psdname, \\\\\\n 'acqtime':shdr['AcqTime'], \\\\\\n 'series':int(shdr['SeriesNumber']), \\\\\\n 'plane':hdr['plane'].strip(), \\\\\\n 'type':self.imgtype.get(psdname,None), \\\\\\n 'plane':hdr['plane'], \\\\\\n 'acqtime':shdr['SeriesTime'], \\\\\\n# 'fmapdir':None, \\\\\\n 'refdat':None, \\\\\\n 'imgfile':None, \\\\\\n 'base':None, \\\\\\n 'tdim':int(hdr['tdim']), \\\\\\n 'echo_spacing':None, \\\\\\n 'filetype':'brik', \\\\\\n 'suffix':self.suffix.get(hdr['filetype'], 'brik'), \\\\\\n 'data_filetype':hdr['filetype']}\\n if info['type'] == 'localizer':\\n# Don't process the localizer.\\n return info\\n if isinstance(info['acqtime'], int):\\n info['acquisition_time'] = time.ctime(info['acqtime'])\\n if nhdr.get('ImageFormat',('unknown'))[0] == 'DERIVED' and info['type'] == 'epi':\\n# Sometimes screenshots are defined as epis.\\n info['type'] = None\\n\\n# Call the method appropriate to the type of scan in this series.\\n stat = apply( self.GetInfoMethods.get(info['type'], self._NoInfo), \\\\\\n [info, path])\\n if stat:\\n info = {'type':'break'}\\n return info\\n info['suffix'] = self.suffix.get(info['filetype'], 'brik')\\n return info\",\n \"def process(self, image):\",\n \"def read_img(components):\\n\\n img_buf = open(components[0], 'rb').read()\\n\\n if not img_buf:\\n raise Exception('image not read, path=%s' % components[0])\\n\\n arr = np.fromstring(img_buf, np.uint8)\\n img = cv2.imdecode(arr, cv2.IMREAD_COLOR)\\n components[1], components[2] = img.shape[:2]\\n components[10] = img\\n\\n return components\",\n \"def read_image(img_path):\\n img = imageio.imread(uri=img_path)\\n return img\",\n \"def load_image(nom):\\n print(\\\"load_image : [\\\", nom, \\\"]\\\")\\n fic = gdal.Open(nom)\\n print(fic)\\n return fic.ReadAsArray(), fic.GetGeoTransform()\",\n \"def _read_image(self, image_path:str, label:str):\\n # Get the full path to the image\\n image = \\\"\\\"\\n if label == \\\"real\\\":\\n image = os.path.join(self.root, \\\"real\\\", image_path)\\n else:\\n image = os.path.join(self.root, \\\"fake\\\", image_path)\\n \\n # Read the image\\n image = cv2.imread(image)\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n\\n # Normalize the image\\n image = image / 255.0\\n\\n # Convert the image to floating point to use it as\\n # an input to the PyTorch model\\n image = image.astype(np.float32)\\n\\n return image\",\n \"def image_info(self):\\n\\n if not self._image_info:\\n path_image_info = os.path.join(\\n self._path, f\\\"ImageSet_{self._image['ImageSetID']}.ImageInfo\\\"\\n )\\n\\n # Make sure the ImageInfo file really exists\\n if not os.path.exists(path_image_info):\\n self.logger.warning(\\\"ImageInfo path doesn't exist: %s\\\", path_image_info)\\n return None\\n\\n self.logger.debug(\\\"Reading image data from: %s\\\", path_image_info)\\n self._image_info = pinn_to_dict(path_image_info)\\n\\n return self._image_info\",\n \"def read_image(path: str):\\n return Image.open(path, mode=\\\"r\\\")\",\n \"def read_image(path):\\n img = ndimage.imread(path, mode=\\\"RGB\\\") \\n return img\",\n \"def open_image_and_meta(image_bytes):\\n with MemoryFile(image_bytes) as memfile:\\n with memfile.open() as src:\\n meta = src.meta\\n arr = reshape_as_image(src.read())\\n return arr, meta\",\n \"def read_first_image(file_name):\\n pixels = None\\n try : # open file_name\\n with fits.open(file_name) as fits_blocks:\\n block = fits_blocks[0]\\n pixels = block.data\\n header = block.header\\n except IOError:\\n print(\\\"Error while opening/reading file !\\\")\\n exit()\\n except FileNotFoundError:\\n print(\\\"Error with file name\\\")\\n exit()\\n\\n\\n return header, pixels\",\n \"def read_image(img):\\n out = Image.open(img)\\n return Technicolor(out)\",\n \"def load(image_path):\\n out = None\\n\\n #####################################\\n # START YOUR CODE HERE #\\n #####################################\\n # Use skimage io.imread\\n out = io.imread(image_path)\\n ######################################\\n # END OF YOUR CODE #\\n ######################################\\n\\n return out\",\n \"def load_image(self, image_id):\\n # Load image\\n# print(self.image_info[image_id]['path'])\\n image = cv2.imread(self.image_info[image_id]['path'],cv2.IMREAD_GRAYSCALE) \\n image = image[:,:, np.newaxis] #Add 1 dimension for grayscale images\\n return image\",\n \"def read_image(filename, representation):\\n img = imread(filename)\\n img = int2float(img)\\n if representation == GS_REP:\\n img = rgb2gray(img)\\n return img\",\n \"def get_image_data(self):\\n raise NotImplementedError(str(type(self)) + 'does not'\\n 'implement get_image.')\",\n \"def iread(filename, *args, verbose=True, **kwargs):\\n\\n # determine if file is valid:\\n # assert isinstance(filename, str), 'filename must be a string'\\n\\n\\n # TODO read options for image\\n # opt = {\\n # 'uint8': False,\\n # 'single': False,\\n # 'double': False,\\n # 'grey': False,\\n # 'grey_709': False,\\n # 'gamma': 'sRGB',\\n # 'reduce': 1.0,\\n # 'roi': None\\n # }\\n\\n if isinstance(filename, str) and (filename.startswith(\\\"http://\\\") or filename.startswith(\\\"https://\\\")):\\n # reading from a URL\\n\\n resp = urllib.request.urlopen(filename)\\n array = np.asarray(bytearray(resp.read()), dtype=\\\"uint8\\\")\\n image = cv.imdecode(array, -1)\\n print(image.shape)\\n return (image, filename)\\n\\n elif isinstance(filename, (str, Path)):\\n # reading from a file\\n\\n path = Path(filename).expanduser()\\n\\n if any([c in \\\"?*\\\" for c in str(path)]):\\n # contains wildcard characters, glob it\\n # recurse and return a list\\n # https://stackoverflow.com/questions/51108256/how-to-take-a-pathname-string-with-wildcards-and-resolve-the-glob-with-pathlib\\n \\n parts = path.parts[1:] if path.is_absolute() else path.parts\\n p = Path(path.root).glob(str(Path(\\\"\\\").joinpath(*parts)))\\n pathlist = list(p)\\n\\n if len(pathlist) == 0 and not path.is_absolute():\\n # look in the toolbox image folder\\n path = Path(__file__).parent / \\\"images\\\" / path\\n parts = path.parts[1:] if path.is_absolute() else path.parts\\n p = Path(path.root).glob(str(Path(\\\"\\\").joinpath(*parts)))\\n pathlist = list(p)\\n \\n if len(pathlist) == 0:\\n raise ValueError(\\\"can't expand wildcard\\\")\\n\\n imlist = []\\n pathlist.sort()\\n for p in pathlist:\\n imlist.append(iread(p, **kwargs))\\n return imlist\\n\\n else:\\n # read single file\\n\\n if not path.exists():\\n if path.is_absolute():\\n raise ValueError(f\\\"file {filename} does not exist\\\")\\n # file doesn't exist\\n # see if it matches the supplied images\\n path = Path(__file__).parent / \\\"images\\\" / path\\n\\n if not path.exists():\\n raise ValueError(f\\\"file {filename} does not exist, and not found in supplied images\\\")\\n\\n # read the image\\n # TODO not sure the following will work on Windows\\n im = cv.imread(path.as_posix(), **kwargs) # default read-in as BGR\\n\\n if im is None:\\n # TODO check ValueError\\n raise ValueError(f\\\"Could not read {filename}\\\")\\n\\n return (im, str(path))\\n\\n elif islistof(filename, (str, Path)):\\n # list of filenames or URLs\\n # assume none of these are wildcards, TODO should check\\n out = []\\n for file in filename:\\n out.append(iread(file, *args))\\n return out\\n else:\\n raise ValueError(filename, 'invalid filename')\",\n \"def _get_image_info(\\n image_id: int,\\n width: int,\\n height: int,\\n file_name: str,\\n license_id=1,\\n flickr_url=\\\"\\\",\\n coco_url=\\\"\\\",\\n date_captured=datetime.datetime.utcnow().isoformat(' ')):\\n image_info = {\\n \\\"id\\\": image_id,\\n \\\"width\\\": width,\\n \\\"height\\\": height,\\n \\\"file_name\\\": file_name,\\n \\\"license\\\": license_id,\\n \\\"flickr_url\\\": flickr_url,\\n \\\"coco_url\\\": coco_url,\\n \\\"date_captured\\\": date_captured,\\n }\\n\\n return image_info\",\n \"def get_image(inf):\\n try:\\n x, y = Image.open(inf).size\\n except FileNotFoundError:\\n print(\\\"Error: {} file not found.\\\".format(inf))\\n sys.exit(1)\\n\\n pixels = list(Image.open(inf).getdata())\\n return x, y, pixels\",\n \"def readImage(self, path, tt=1):\\n return cv2.imread( path, tt)\",\n \"def test_read(self):\\n for line in TESTIMAGES.split(\\\"\\\\n\\\"):\\n vals = line.split()\\n name = vals[0]\\n dim1, dim2 = [int(x) for x in vals[1:3]]\\n mini, maxi, mean, stddev = [float(x) for x in vals[3:]]\\n obj = marccdimage()\\n obj.read(self.fn[name])\\n self.assertAlmostEqual(mini, obj.getmin(), 2, \\\"getmin\\\")\\n self.assertAlmostEqual(maxi, obj.getmax(), 2, \\\"getmax\\\")\\n self.assertAlmostEqual(mean, obj.getmean(), 2, \\\"getmean\\\")\\n self.assertAlmostEqual(stddev, obj.getstddev(), 2, \\\"getstddev\\\")\\n self.assertEqual(dim1, obj.dim1, \\\"dim1\\\")\\n self.assertEqual(dim2, obj.dim2, \\\"dim2\\\")\",\n \"def read_image(image_path):\\n if not os.path.exists(image_path):\\n raise IOError('File does not exist: %s' % image_path)\\n else:\\n return Image.open(image_path)\",\n \"def read_img(img_path):\\n return sitk.GetArrayFromImage(sitk.ReadImage(img_path))\",\n \"def _process_image(filename, coder):\\n # Read the image file.\\n with tf.gfile.FastGFile(filename, 'rb') as f:\\n image_data = f.read()\\n \\n # Convert any PNG to JPEG's for consistency.\\n if _is_png(filename):\\n print('Converting PNG to JPEG for %s' % filename)\\n image_data = coder.png_to_jpeg(image_data)\\n # Decode the RGB JPEG.\\n image = coder.decode_jpeg(image_data)\\n\\n # Check that image converted to RGB\\n assert len(image.shape) == 3\\n height = image.shape[0]\\n width = image.shape[1]\\n assert image.shape[2] == 3\\n\\n return image_data, height, width\",\n \"def read_image(filename):\\n img = Image.open(filename)\\n im = np.array(img)\\n return im\",\n \"def read_image(image_path):\\n im = Image.open(image_path, 'r')\\n return np.array(im)\",\n \"def img_read(name):\\n\\n img = cv2.imread(name)\\n\\n return img\",\n \"def do_info (self, line) :\\n\\t\\tprint\\n\\t\\tprint get_info_string( self.__image )\\n\\t\\tprint\",\n \"def get_input(path):\\n img = imread(path)\\n return img\",\n \"def build_img_info(img_root):\\n imgs = []\\n feats = []\\n K = []\\n for i, name in enumerate(os.listdir(img_root)):\\n if '.jpg' in name or '.JPG' in name:\\n path = os.path.join(img_root, name)\\n img = cv2.imread(path)\\n imgs.append(img)\\n feature_process = FeatureProcess(img)\\n kpt, des = feature_process.extract_features()\\n photo_info = PhotoExifInfo(path)\\n photo_info.get_tags()\\n K.append(photo_info.get_intrinsic_matrix())\\n A = photo_info.get_area()\\n D = photo_info.get_diam()\\n feats.append({'kpt': kpt, 'des': des, 'A': A, 'D': D})\\n return imgs, feats, K\",\n \"def imread(fname):\\n try:\\n fp = open(fname, 'rb')\\n im = Image.open(fp)\\n except:\\n sys.stderr.write('IOException: Invalid input type on '+fname+'\\\\n')\\n sys.exit(1)\\n else:\\n if im.format not in FILETYPES:\\n sys.stderr.write('IOException: Invalid image type\\\\n')\\n sys.exit(1)\\n \\n fa = np.array(im.convert('F'))\\n im = im.convert('RGB')\\n wa = np.array(im)\\n \\n fp.close()\\n\\n return fa, wa\",\n \"def fetchInfo(self, path):\\n\\n\\n img = self.getImageObject(path)\\n\\n if isinstance(img, ImageFile):\\n return img.size\\n else:\\n return [img.width, img.height]\",\n \"def _getImage(self, img):\\n\\n # lazily fill in some attributes\\n if not 'local_file_path' in img:\\n img['local_file_path'] = os.path.join(self.image_root, img['filename'])\\n if not 'feat' in img: # also fill in the features\\n # NOTE: imgid is an integer, and it indexes into features\\n fn = os.path.basename(img['filename'])\\n return img\",\n \"def read_img(img_path):\\n img_list=[]\\n print('image loading...')\\n for _,_,files in os.walk(img_path):\\n for f in files:\\n if f.find('.dcm')>=0:\\n tmp_img=dicom.dcmread(os.path.join(img_path,f))\\n tmp_img=tmp_img.pixel_array#[0::2,0::2]\\n img_list.append(tmp_img)\\n img_data=np.array(img_list)\\n print('done')\\n return img_data\",\n \"def __read_image(self, filename):\\n self.image = cv2.imread(filename)\\n self.image = cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB)\\n self.im_copy = self.image.copy()\\n self.height, self.width = self.image.shape[:2]\\n self.debug = 0\",\n \"def process_image(self):\\n pass\",\n \"def get_raw_img(image_name):\\n # IMREAD_COLOR ignores transparency (!)\\n return cv2.imread(image_name, cv2.IMREAD_COLOR)\",\n \"def Read(image_path):\\n # use cv2.imread() to read an images.\\n # syntax : cv2.imread(filename, flag=None)\\n return cv2.imread(image_path, 0)\",\n \"def image_data_info(page):\\n xObject = page['/Resources']['/XObject'].getObject()\\n\\n for obj_key in xObject:\\n obj = xObject[obj_key]\\n if obj['/Subtype'] == '/Image':\\n width, height = (obj['/Width'], obj['/Height'])\\n num_bytes = len(obj._data)\\n density = num_bytes * 1.0 / (width * height)\\n return {'width': width, 'height': height, 'size': num_bytes, 'density': density}\\n\\n return None\",\n \"def get_img_info(self, idx):\\n\\n image = self.get_img(idx)\\n img_height = image.size[0]\\n img_width = image.size[1]\\n\\n return {\\\"height\\\": img_height, \\\"width\\\": img_width}\",\n \"def read_image(fileame, representation):\\n validate_representation(representation)\\n\\n im = imread(fileame)\\n if representation == 1 and is_rgb(im):\\n # We should convert from Grayscale to RGB\\n im = rgb2gray(im)\\n return im.astype(np.float32)\\n\\n return normlized_image(im)\",\n \"def read_img(img_id, train_or_test, size):\\n img = image.load_img(join(data_dir, train_or_test, img_id + '.jpg'), target_size=size)\\n # img = image.img_to_array(img)\\n return img\",\n \"def read_img(img_path:str) -> object:\\n img = cv2.imread(img_path)\\n return img\",\n \"def load_image(self, image_id):\\n # Load image\\n path = self.image_info[image_id]['path']\\n if path.endswith(\\\".png\\\" or \\\".jpg\\\"):\\n image = skimage.io.imread(path)\\n elif path.endswith(\\\".dcm\\\"):\\n ds = pydicom.read_file(path)\\n image = ds.pixel_array\\n # If grayscale. Convert to RGB for consistency.\\n if image.ndim != 3:\\n image = skimage.color.gray2rgb(image)\\n # If has an alpha channel, remove it for consistency\\n if image.shape[-1] == 4:\\n image = image[..., :3]\\n return image\",\n \"def fitsread(imgname, header = False):\\n try:\\n if header:\\n img_data, header = pyfits.getdata(imgname, ignore_missing_end = True, header = True)\\n return img_data, header\\n else:\\n img_data = pyfits.getdata(imgname, ignore_missing_end = True)\\n return img_data\\n except IOError:\\n print \\\"FITSREAD: Unable to open FITS image %s\\\" %imgname\\n \\n return\",\n \"def read_image(image_file_path: str):\\n\\n pixels = numpy.array(Image.open(image_file_path))\\n\\n return pixels\",\n \"def read_image(self, image):\\n if image not in self.content:\\n img = cv2.imread(image)\\n img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n img = cv2.copyMakeBorder(img, 5, 5, 5, 5, cv2.BORDER_CONSTANT)\\n text = pytesseract.image_to_string(img).lower()\\n self.content[image] = text\\n return text\\n return self.content[image]\",\n \"def process_image(file_path):\\n img_array = io.imread(file_path)\\n detections, shapes, descriptors = detect_faces(person_database,img_array)\\n\\n names = []\\n\\n for desc in descriptors:\\n name = find_match(person_database, desc)\\n names.append(name)\\n\\n return pic_array, names, detections, shapes, descriptors\",\n \"def read_image(self, filePath):\\n if filePath.endswith(\\\".dcm\\\"):\\n image = sitk.ReadImage(filePath)\\n image = sitk.GetArrayFromImage(image).astype(\\\"int16\\\")\\n image = np.expand_dims(image[0,:,:], -1)\\n elif filePath.endswith(\\\".png\\\"):\\n image = cv2.imread(filePath)\\n image = np.array(image, dtype = \\\"int16\\\")\\n elif filePath.endswith(\\\".mha\\\"):\\n image = sitk.ReadImage(filePath)\\n image = sitk.GetArrayFromImage(image).astype(\\\"int16\\\")\\n image = np.transpose(image,(1,2,0))\\n return image\",\n \"def read(self):\\n with self.lock:\\n return self.image\",\n \"def imread(path):\\n with open(path, 'rb') as f:\\n with PIL.Image.open(f) as img:\\n return img.convert('RGB')\",\n \"def open_image(infile):\\n with fits.open(infile) as f:\\n header = f[0].header\\n data = f[0].data\\n if data.ndim == 2:\\n # NAXIS=2: [Y, X]\\n image = data\\n elif data.ndim == 3 and data.shape[0] == 1:\\n # NAXIS=3: [FREQ=1, Y, X]\\n image = data[0, :, :]\\n elif data.ndim == 4 and data.shape[0] == 1 and data.shape[1] == 1:\\n # NAXIS=4: [STOKES=1, FREQ=1, Y, X]\\n image = data[0, 0, :, :]\\n else:\\n raise ValueError(\\\"Slice '{0}' has invalid dimensions: {1}\\\".format(\\n infile, data.shape))\\n return (header, image)\",\n \"def process_image(im):\\r\\n h, _, _ = im.shape\\r\\n im_gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)\\r\\n \\r\\n # Divide the picture into 3 regions\\r\\n l1 = int(0.65*h)\\r\\n l2 = int(0.77*h)\\r\\n im1 = im_gray[:l1,:]\\r\\n im2 = im_gray[l1+1:l2,:]\\r\\n im3 = im_gray[l2+1:,:]\\r\\n \\r\\n # Extract 4 pictures\\r\\n pics = extract_4_pics(im, im1)\\r\\n \\r\\n # Extract the word size\\r\\n word_size = extract_word_size(im2)\\r\\n \\r\\n # Extract the letters\\r\\n letters = extract_letters(im3)\\r\\n \\r\\n print 'word size =', word_size\\r\\n print 'letters =', letters\\r\\n for i, pic in enumerate(pics):\\r\\n imsave(str(i) + '.png', pic)\\r\\n\\r\\n return word_size, letters, pics\",\n \"def read_image(path):\\n reader = sitk.ImageSeriesReader()\\n dicom_filenames = reader.GetGDCMSeriesFileNames(path)\\n reader.SetFileNames(dicom_filenames)\\n reader.LoadPrivateTagsOn()\\n img = reader.Execute()\\n img.SetOrigin((0, 0, 0))\\n return img\",\n \"def read_image(path):\\n\\n image = cv2.imread(path)\\n return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\",\n \"def read_image(filename, representation):\\n\\n color_flag = True #if RGB image\\n image = imread(filename)\\n\\n float_image = image.astype(np.float64)\\n\\n if not np.all(image <= 1):\\n float_image /= NORMALIZE #Normalized to range [0,1]\\n\\n if len(float_image.shape) != 3 : #Checks if RGB or Grayscale\\n color_flag = False\\n\\n if color_flag and representation == 1 : #Checks if need RGB to Gray\\n return skimage.color.rgb2gray(float_image)\\n\\n # Same coloring already\\n return float_image\",\n \"def load_image(self, image_index):\\n\\t\\t\\timage_info = self.coco.loadImgs(self.image_ids[image_index])[0]\\n\\t\\t\\tpath = os.path.join(self.data_dir, 'images', self.set_name, image_info['file_name'])\\n\\t\\t\\treturn read_image_bgr(path)\",\n \"def read_image(image_path: str):\\n\\treturn cv.imread(image_path, cv.IMREAD_UNCHANGED)\",\n \"def generate_image_info(image):\\n image = ee.Image(image)\\n image_vis = image.visualize(**{\\n 'min': image_min,\\n 'max': image_max,\\n 'palette': image_palette\\n })\\n\\n print(image_min, image_max)\\n\\n if 'hillshade' in r and r['hillshade']:\\n image_vis = hillshade(image_vis,\\n image.subtract(image_min).divide(ee.Image.constant(image_max).subtract(image_min)),\\n True)\\n\\n m = image_vis.getMapId()\\n\\n mapid = m.get('mapid')\\n token = m.get('token')\\n\\n url = 'https://earthengine.googleapis.com/map/{mapid}/{{z}}/{{x}}/{{y}}?token={token}'.format(\\n mapid=mapid,\\n token=token\\n )\\n\\n result = {\\n 'mapid': mapid,\\n 'token': token,\\n 'url': url\\n }\\n return result\",\n \"def read_images(self, img_name, label_name):\\n image_string = tf.read_file(img_name)\\n image_decoded = tf.image.decode_jpeg(image_string, channels=3)\\n label_string = tf.read_file(label_name)\\n label_decoded = tf.image.decode_jpeg(label_string, channels=1)\\n return image_decoded, label_decoded\",\n \"def imread(fname):\\r\\n return skimage.io.imread(fname)\",\n \"def read_image(image_path):\\n return np.array(load_img(image_path, color_mode='grayscale')) / 255\",\n \"def read_map_file(path):\\r\\n with open(path) as f:\\r\\n dir_name = os.path.dirname(path)\\r\\n img = cv2.imread(dir_name + '/' + f.readline().strip())\\r\\n assert img.shape[0] > 0 and img.shape[1] > 0, 'Can not open image file'\\r\\n meter_per_pixel = float(f.readline().strip())\\r\\n ori_str = f.readline().strip().split()\\r\\n origin = np.array([int(ori_str[0]), int(ori_str[1])])\\r\\n init_heading = float(ori_str[2])\\r\\n return img, meter_per_pixel, origin, init_heading\",\n \"def get_image(image_path):\\r\\n image = Image.open(image_path, 'r')\\r\\n width, height = image.size\\r\\n pixel_values = list(image.getdata())\\r\\n if image.mode == 'RGB':\\r\\n channels = 3\\r\\n elif image.mode == 'L':\\r\\n channels = 1\\r\\n else:\\r\\n print(\\\"Unknown mode: %s\\\" % image.mode)\\r\\n return None\\r\\n pixel_values = np.array(pixel_values).reshape((1,width, height, channels))\\r\\n # print(pixel_values.shape)\\r\\n return pixel_values\",\n \"def read_image(filename, representation):\\n image = scipy.misc.imread(filename)\\n if int(representation) == 1:\\n image = rgb2gray(image)\\n return img_as_float(image)\",\n \"def __read_img_file(filename, label):\\n image = cv2.cvtColor(cv2.imread(filename), cv2.COLOR_BGR2RGB)\\n height, width, _ = image.shape\\n image = cv2.resize(image, (img_size, img_size))\\n # A label is consist of [y1, x1, y2, x2, class_idx]\\n label = np.reshape(label, (-1, 5))\\n rel_bboxes = label[..., 0:4] / np.array([height, width, height, width], np.float32)\\n label = np.concatenate([rel_bboxes, np.expand_dims(label[..., -1], 1)], axis=-1)\\n return image, label\",\n \"def input_image():\\r\\n im = cv2.imread('im7.png')\\r\\n return im\",\n \"def getImage(self, imageName):\\n if imageName in self._imageDictionary:\\n return self._imageDictionary[imageName]\\n else:\\n print(str(imageName) + \\\" is not in the dictionary\\\")\",\n \"def read_image(img_path):\\n got_img = False\\n if not osp.exists(img_path):\\n raise IOError(\\\"{} does not exist\\\".format(img_path))\\n while not got_img:\\n try:\\n img = Image.open(img_path).convert('RGB')\\n got_img = True\\n except IOError:\\n from ipdb import set_trace; set_trace()\\n print(\\\"IOError incurred when reading '{}'. Will redo. Don't worry. Just chill.\\\".format(img_path))\\n pass\\n return img\",\n \"def generate_image_info(im, params):\\n im = ee.Image(im)\\n\\n # some images are scaled to a factor of 10.\\n if params.get('scale') == 'log':\\n im = im.log10()\\n\\n im = im.sldStyle(params.get('sld_style'))\\n\\n m = im.getMapId()\\n\\n mapid = m.get('mapid')\\n token = m.get('token')\\n\\n url = 'https://earthengine.googleapis.com/map/{mapid}/{{z}}/{{x}}/{{y}}?token={token}'.format(\\n mapid=mapid,\\n token=token\\n )\\n\\n result = {\\n 'mapid': mapid,\\n 'token': token,\\n 'url': url\\n }\\n return result\",\n \"def parse_image_meta(meta):\\n image_id = meta[:, 0]\\n image_shape = meta[:, 1:4]\\n window = meta[:, 4:8] # (x1, y1, x2, y2) window of image in in pixels\\n active_class_ids = meta[:, 8:]\\n return image_id, image_shape, window, active_class_ids\",\n \"def get_image_data (file_path, metadata_required):\\n lookup = ImageLookup()\\n return lookup.lookup_by_filename(file_path, metadata_required=False)\",\n \"def __read_image(self, path):\\n path = 'data/' + path\\n image = cv2.imread(path)\\n\\n # Convert greyscale image to BGR\\n if image.shape[-1] == 1:\\n image = np.dstack([image, image, image])\\n\\n # Convert BGR image to RGB image\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n\\n return image\",\n \"def extract_exif_data(self, path_img):\\n try:\\n img = PIL.Image.open(path_img)\\n self.exif = {PIL.ExifTags.TAGS[k]: v\\n for k, v in img._getexif().items()\\n if k in PIL.ExifTags.TAGS}\\n if 'GPSInfo' in self.exif.keys():\\n latitude = str(self.getCoordinate(self.exif['GPSInfo'][2], self.exif['GPSInfo'][1]))\\n longitude = str(self.getCoordinate(self.exif['GPSInfo'][4], self.exif['GPSInfo'][3]))\\n self.exif['GPSInfo'] = \\\"https://www.google.com/maps/search/?api=1&query=\\\" + str(latitude) + \\\",\\\" + str(\\n longitude)\\n return self.exif\\n except:\\n return None\",\n \"def readImg(filename, h1, h2, w1, w2):\\n img = cv2.imread(filename, 1)\\n # plt.figure()\\n # plt.imshow(img)\\n img = img[h1:h2, w1:w2]\\n return img\",\n \"def read_image(filename, representation):\\n im = imread(filename)\\n if representation == GS_REP:\\n im = rgb2gray(im)\\n im = np.divide(im, MAX_VALUE - 1)\\n return im\",\n \"def read_image(img_path):\\n got_img = False\\n if not osp.exists(img_path):\\n raise IOError(\\\"{} does not exist\\\".format(img_path))\\n while not got_img:\\n try:\\n img = Image.open(img_path).convert('RGB')\\n got_img = True\\n except IOError:\\n print(\\\"IOError incurred when reading '{}'. Will redo. Don't worry. Just chill.\\\".format(img_path))\\n pass\\n return img\",\n \"def getimg(filename):\\n return np.asarray(Image.open('imgdb/'+filename))\",\n \"def read_img(img_id, data_dir, train_or_test, size):\\n img = image.load_img(os.path.join(data_dir, train_or_test, '%s.jpg' % img_id), target_size=size)\\n img = image.img_to_array(img)\\n return img\",\n \"def facts(url_file_stream_or_string):\\n source = imagefacts.open_resource._open_resource(url_file_stream_or_string, _handle_url)\\n data = source.read()\\n return imagefacts.getimageinfo.getImageInfo(data)\",\n \"def extract(self, source):\\n\\t\\tp = Parser()\\n\\t\\tf = open_pds(source)\\n\\t\\tif self.log: self.log.debug(\\\"Parsing '%s'\\\" % (source))\\n\\t\\tself.labels = p.parse(f)\\n\\t\\tif self.log: self.log.debug(\\\"Found %d labels\\\" % (len(self.labels)))\\n\\t\\tif self._check_image_is_supported():\\n\\t\\t\\tif self.log: self.log.debug(\\\"Image in '%s' is supported\\\" % (source))\\n\\t\\t\\tdim = self._get_image_dimensions()\\n\\t\\t\\tloc = self._get_image_location()\\n\\t\\t\\timageSampleBits = int(self.labels['IMAGE']['SAMPLE_BITS'])\\n\\t\\t\\timageSampleType = self.labels['IMAGE']['SAMPLE_TYPE']\\n\\t\\t\\tmd5Checksum = self._get_image_checksum()\\n\\t\\t\\tif self.log: self.log.debug(\\\"Image dimensions should be %s\\\" % (str(dim)))\\n\\t\\t\\tif self.log: self.log.debug(\\\"Seeking to image data at %d\\\" % (loc))\\n\\t\\t\\tf.seek(loc)\\n\\t\\t\\tif imageSampleBits == 8:\\n\\t\\t\\t\\treadSize = dim[0] * dim[1]\\n\\t\\t\\telif imageSampleBits == 16:\\n\\t\\t\\t\\treadSize = dim[0] * dim[1] * 2\\n\\t\\t\\tprint readSize\\n\\t\\t\\tif self.log: self.log.debug(\\\"Seek successful, reading data (%s)\\\" % (readSize))\\n\\t\\t\\t# rawImageData = f.readline()\\n\\t\\t\\t# f.seek(-int(self.labels[\\\"RECORD_BYTES\\\"]), os.SEEK_CUR)\\n\\t\\t\\trawImageData = f.read(readSize)\\n\\t\\t\\tif md5Checksum:\\n\\t\\t\\t\\trawImageChecksum = hashlib.md5(rawImageData).hexdigest()\\n\\t\\t\\t\\tchecksumVerificationPassed = rawImageChecksum == md5Checksum and True or False\\n\\t\\t\\t\\tif not checksumVerificationPassed:\\n\\t\\t\\t\\t\\tif self.log: self.log.debug(\\\"Secure hash verification failed\\\")\\n\\t\\t\\t\\t\\tif self.raisesChecksumError:\\n\\t\\t\\t\\t\\t\\terrorMessage = \\\"Verification failed! Expected '%s' but got '%s'.\\\" % (md5Checksum, rawImageChecksum)\\n\\t\\t\\t\\t\\t\\traise ChecksumError, errorMessage\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif self.log: self.log.debug(\\\"Secure hash verification passed\\\")\\n\\t\\t\\tif self.log: self.log.debug(\\\"Read successful (len: %d), creating Image object\\\" % (len(rawImageData)))\\n\\t\\t\\t# The frombuffer defaults may change in a future release;\\n\\t\\t\\t# for portability, change the call to read:\\n\\t\\t\\t# frombuffer(mode, size, data, 'raw', mode, 0, 1).\\n\\t\\t\\tif (imageSampleBits == 16) and imageSampleType == ('MSB_INTEGER'):\\n\\t\\t\\t\\t#img = Image.frombuffer('I', dim, rawImageData, 'raw', 'I;16BS', 0, 1)\\n\\t\\t\\t\\timg = Image.frombuffer('F', dim, rawImageData, 'raw', 'F;16B', 0, 1)\\n\\t\\t\\t\\timg = ImageMath.eval(\\\"convert(a/16.0, 'L')\\\", a=img)\\n\\t\\t\\telse:\\n\\t\\t\\t\\timg = Image.frombuffer('L', dim, rawImageData, 'raw', 'L', 0, 1)\\n\\t\\t\\tif self.log:\\n\\t\\t\\t\\tself.log.debug(\\\"Image result: %s\\\" % (str(img)))\\n\\t\\t\\t\\tself.log.debug(\\\"Image info: %s\\\" % (str(img.info)))\\n\\t\\t\\t\\tself.log.debug(\\\"Image mode: %s\\\" % (str(img.mode)))\\n\\t\\t\\t\\tself.log.debug(\\\"Image size: %s\\\" % (str(img.size)))\\n\\t\\telse:\\n\\t\\t\\tif self.log: self.log.error(\\\"Image is not supported '%s'\\\" % (source))\\n\\t\\t\\timg = None\\n\\t\\tf.close()\\n\\n\\t\\treturn img, self.labels\",\n \"def input(self):\\n\\t\\treturn self.image\",\n \"def load_image(self, img_name):\\n img_data = cv2.imread(img_name, 0)\\n return img_data\",\n \"def readImage(imageName, flags=cv2.IMREAD_GRAYSCALE):\\r\\n if imageName.__class__ != \\\"\\\".__class__:\\r\\n print(\\\"ERROR - readImage: Input type must be a string (image name). Was: \\\", imageName.__class__)\\r\\n return None\\r\\n\\r\\n # cv2 loads an image in BGR format. Here we have a default value used to load it in grayscale mode\\r\\n image = cv2.imread(imageName, flags)\\r\\n return image\",\n \"def get_image_params(image_path):\\n image = cv2.imread(image_path)\\n\\n return image, image.shape\",\n \"def _open_image(self, path):\\n return cv.imread(path, 1)\\n # .astype(float)\",\n \"def load_image(filename):\\n with open(filename, 'rb') as img_handle:\\n img = Image.open(img_handle)\\n img_data = img.getdata()\\n if img.mode.startswith('RGB'):\\n pixels = [round(.299 * p[0] + .587 * p[1] + .114 * p[2])\\n for p in img_data]\\n elif img.mode == 'LA':\\n pixels = [p[0] for p in img_data]\\n elif img.mode == 'L':\\n pixels = list(img_data)\\n else:\\n raise ValueError('Unsupported image mode: %r' % img.mode)\\n w, h = img.size\\n return {'height': h, 'width': w, 'pixels': pixels}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72628486","0.72226435","0.6992954","0.6965782","0.6876386","0.68329227","0.6822123","0.68075496","0.6758192","0.6675034","0.6649149","0.6627219","0.6605855","0.660208","0.6594365","0.65857846","0.6574458","0.6571832","0.6551282","0.65477014","0.65150887","0.6500088","0.6498421","0.6484258","0.64821255","0.64788777","0.64529884","0.64347917","0.6429904","0.64220023","0.6418864","0.64057183","0.63978034","0.6396632","0.63962835","0.63908404","0.6378583","0.63784915","0.637627","0.6359455","0.6348777","0.6339746","0.6337124","0.6333099","0.63245404","0.631913","0.63156587","0.63144714","0.6306402","0.6299224","0.6297234","0.6294848","0.6254201","0.625124","0.6244615","0.6244138","0.6240435","0.6234931","0.6222696","0.62211865","0.6220273","0.6199955","0.61988896","0.6190136","0.6186386","0.6180324","0.61780167","0.61777973","0.6175079","0.6173031","0.61662096","0.61606133","0.6154262","0.6140873","0.6135946","0.6135829","0.61357945","0.61282223","0.6127465","0.61258453","0.6119198","0.61107224","0.6100164","0.6095051","0.609198","0.60816747","0.60811526","0.6079313","0.6072328","0.6067591","0.6067257","0.6066834","0.60658807","0.60597664","0.60548115","0.60487103","0.60436964","0.6042961","0.60350674","0.6034436"],"string":"[\n \"0.72628486\",\n \"0.72226435\",\n \"0.6992954\",\n \"0.6965782\",\n \"0.6876386\",\n \"0.68329227\",\n \"0.6822123\",\n \"0.68075496\",\n \"0.6758192\",\n \"0.6675034\",\n \"0.6649149\",\n \"0.6627219\",\n \"0.6605855\",\n \"0.660208\",\n \"0.6594365\",\n \"0.65857846\",\n \"0.6574458\",\n \"0.6571832\",\n \"0.6551282\",\n \"0.65477014\",\n \"0.65150887\",\n \"0.6500088\",\n \"0.6498421\",\n \"0.6484258\",\n \"0.64821255\",\n \"0.64788777\",\n \"0.64529884\",\n \"0.64347917\",\n \"0.6429904\",\n \"0.64220023\",\n \"0.6418864\",\n \"0.64057183\",\n \"0.63978034\",\n \"0.6396632\",\n \"0.63962835\",\n \"0.63908404\",\n \"0.6378583\",\n \"0.63784915\",\n \"0.637627\",\n \"0.6359455\",\n \"0.6348777\",\n \"0.6339746\",\n \"0.6337124\",\n \"0.6333099\",\n \"0.63245404\",\n \"0.631913\",\n \"0.63156587\",\n \"0.63144714\",\n \"0.6306402\",\n \"0.6299224\",\n \"0.6297234\",\n \"0.6294848\",\n \"0.6254201\",\n \"0.625124\",\n \"0.6244615\",\n \"0.6244138\",\n \"0.6240435\",\n \"0.6234931\",\n \"0.6222696\",\n \"0.62211865\",\n \"0.6220273\",\n \"0.6199955\",\n \"0.61988896\",\n \"0.6190136\",\n \"0.6186386\",\n \"0.6180324\",\n \"0.61780167\",\n \"0.61777973\",\n \"0.6175079\",\n \"0.6173031\",\n \"0.61662096\",\n \"0.61606133\",\n \"0.6154262\",\n \"0.6140873\",\n \"0.6135946\",\n \"0.6135829\",\n \"0.61357945\",\n \"0.61282223\",\n \"0.6127465\",\n \"0.61258453\",\n \"0.6119198\",\n \"0.61107224\",\n \"0.6100164\",\n \"0.6095051\",\n \"0.609198\",\n \"0.60816747\",\n \"0.60811526\",\n \"0.6079313\",\n \"0.6072328\",\n \"0.6067591\",\n \"0.6067257\",\n \"0.6066834\",\n \"0.60658807\",\n \"0.60597664\",\n \"0.60548115\",\n \"0.60487103\",\n \"0.60436964\",\n \"0.6042961\",\n \"0.60350674\",\n \"0.6034436\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64804757"},"document_rank":{"kind":"string","value":"25"}}},{"rowIdx":94991,"cells":{"query":{"kind":"string","value":"Return the nth timepoint"},"document":{"kind":"string","value":"def getTimepoint(self, n, onlyDims = 0):\n\t\tif not self.readers:\n\t\t\tself.getReadersFromFilenames()\n\n\t\tif self.is3DImage():\n\t\t\tif not self.readers:\n\t\t\t\traise Logging.GUIError(\"Attempt to read bad timepoint\", \"Timepoint %d is not defined by the given filenames\" % n)\n\t\t\tself.reader = self.readers[0]\n\t\t\tminZ = n * self.slicesPerTimepoint\n\t\t\tmaxZ = (n+1) * self.slicesPerTimepoint - 1\n\t\t\textract = vtk.vtkExtractVOI()\n\t\t\textract.SetInput(self.reader.GetOutput())\n\t\t\textract.SetVOI(0, self.x - 1, 0, self.y - 1, minZ, maxZ)\n\t\t\tchangeInfo = vtk.vtkImageChangeInformation()\n\t\t\tchangeInfo.SetInput(extract.GetOutput())\n\t\t\tchangeInfo.SetOutputOrigin(0, 0, 0)\n\t\t\tchangeInfo.SetExtentTranslation((0,0,-minZ))\n\t\t\tdata = changeInfo.GetOutput()\n\t\telse:\n\t\t\tif n >= len(self.readers):\n\t\t\t\tn = 0\n\t\t\t\traise Logging.GUIError(\"Attempt to read bad timepoint\", \"Timepoint %d is not defined by the given filenames\" % n)\n\t\t\t\n\t\t\tself.reader = self.readers[n]\n\t\t\tdata = self.reader.GetOutput()\n\n\t\tif not self.voxelsize:\n\t\t\tsize = data.GetSpacing()\n\t\t\tx, y, z = [size.GetElement(x) for x in range(0, 3)]\n\t\t\tself.voxelsize = (x, y, z)\n\t\t\tprint \"Read voxel size\", self.voxelsize\n\n\t\tif onlyDims:\n\t\t\treturn\n\t\t\n\t\treturn data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def nthPersonGetsNthSeat(self, n: int) -> float:\n if n == 1:\n return 1.0\n\n return 1 / 2","def get_second(time_index):\n return np.array(time_index.second).reshape(-1,1)","def get_times_slice(self, index, next_index):\n next_index = tf.minimum(next_index, self.Nt)\n indices = tf.range(index, next_index)\n return tf.gather(self.times, indices, axis=0)","def time(n):\n steps = 3 + math.ceil(n/5.0)*2\n return steps","def nth(f, *N):\n return dmp_ground_nth(f.rep, N, f.lev, f.dom)","def get_t(self, n, c):\n t = 1\n while t * n + t * t * n * n < 2 * c:\n t += 1\n return t - 1","def at(self, t):\n return self.start + (self.end - self.start) * t","def _ith_point(self, i):\n if self.start is S.NegativeInfinity:\n initial = self.stop\n else:\n initial = self.start\n\n if self.start is S.NegativeInfinity:\n step = -1\n else:\n step = 1\n\n return initial + i*step","def __getitem__(self, index: datetime.time) -> float:\n\n # If the index is in the profile, return the index.\n if index in self._profile:\n return self._profile[index]\n\n # If the index is not in the profile, then the closest value needs to be\n # determined. If there is a tie, this does not matter.\n delta_t_to_t_map = {\n (\n abs(\n time.hour * 3600\n + time.minute * 60\n + time.second\n - (index.hour * 3600 + index.minute * 60 + index.second)\n )\n ): time\n for time in self._profile\n }\n return self._profile[delta_t_to_t_map[min(delta_t_to_t_map)]]","def Ni_find(t):\r\n return ep(t) - 1","def time_to_position(tracks, point):\n\n index1 = [index for index, track_point in enumerate(tracks[0]) if track_point == point][0]\n index2 = [index for index, track_point in enumerate(tracks[1]) if track_point == point][0]\n\n # We add one to the length of each track as 0,0 to first point is missing from the track data\n return index1 + 1 + index2 + 1","def ntimestep(self):\n if self._ntimestep is None:\n self._ntimestep = self.get_data_ntimestep()\n\n return self._ntimestep","def window_index_time(t,windowsize,overlap):\r\n \r\n try:\r\n t=t.tolist()\r\n except:\r\n t=t\r\n \r\n t1=t[0]\r\n t2=t1 + timedelta(seconds=windowsize)\r\n pt1=[0]\r\n pt2=[othertime.findNearest(t2,t)]\r\n while t2 < t[-1]:\r\n t1 = t2 - timedelta(seconds=overlap)\r\n t2 = t1 + timedelta(seconds=windowsize)\r\n\r\n pt1.append(othertime.findNearest(t1,t))\r\n pt2.append(othertime.findNearest(t2,t))\r\n \r\n return pt1, pt2","def get_time_to_point(self, point):\n dist = 0\n for node in self.order_hist:\n if point == node:\n return dist\n dist += 1\n return -1","def get_nanosecond(time_index):\n return np.array(time_index.nanosecond).reshape(-1,1)","def nth(n, seq):\n try:\n return seq[n]\n except TypeError:\n return next(itertools.islice(seq, n, None))","def nth(iterable, index):\n return next(itertools.islice(iterable, index, None))","def next_change(self, t=None):\n if t is None:\n t = self.engine.get_now()\n t -= self.initTime\n\n p = float(self.period) / POINTS_PER_CYCLE\n t2 = math.floor(t / p) * p + p\n\n t2 += self.initTime\n\n return t2","def target(self, time, points, dt, num_way):\n start_index = min(int(time / dt), num_way - 1)\n end_index = min(start_index + 1, num_way - 1)\n start_point = points[start_index]\n end_point = points[end_index]\n fraction = float(time % dt) / dt\n return linear_interpolation_two_points(start_point, end_point, fraction).reshape(3)","def get_complex_last_elf(n):\n if math.floor(math.log(n, 3)) == math.ceil(math.log(n, 3)):\n return n\n prev_log3 = 3 ** int(math.floor(math.log(n, 3)))\n next_log3 = prev_log3 + 1\n # print 'log3', prev_log3, next_log3\n midpoint = int((next_log3 - prev_log3) / 2)\n index = n - prev_log3\n # print 'midpoint index', midpoint\n # print 'midpoint', prev_log3 + midpoint\n # print 'index', index\n if index <= midpoint:\n # print 'it\\'s the straight index'\n return index\n else:\n # print 'it\\'s the index times 2 minus half the distance'\n return index * 2 - midpoint","def _getIndexAtTime(self, startTime: float) -> int:\n return round(startTime * self.frameRate * self.sampleWidth)","def time(self):\r\n return self._idx","def timestep_idx(self, timestep):\n timestep = pd.to_datetime(timestep)\n idx = np.where(self.time_index == timestep)[0][0]\n\n return idx","def getPivotPointKeyTime(self, index, view) -> float:\n ...","def time(self, k):\n \n it = Historial.__getitem__(self, k)\n if it != None:\n return it[0]\n else:\n return None","def getWeightTime(self, index):\r\n\t\treturn None","def GetPointForLabel(points):\n # TODO: find the last point at a minute boundary\n return points[-1]","def poly_nth(f, n):\n if n < 0 or n > len(f)-1:\n raise IndexError\n else:\n return f[zzx_degree(f)-n]","def findNthPlayerFromSeat(self, seat, n):\n\t\tfor i in range(1,7):\n\t\t\tindex = (seat + i) % 6\n\t\t\tif self.playerList[index] != None:\n\t\t\t\tif n > 1:\n\t\t\t\t\tn = n - 1\n\t\t\t\telse:\n\t\t\t\t\treturn (self.playerList[index], index)","def get_timing(pidx):\n pgconn = get_dbconn(\"mesosite\")\n cursor = pgconn.cursor()\n cursor.execute(\n \"SELECT avg(timing) from autoplot_timing where appid = %s \"\n \"and valid > (now() - '7 days'::interval)\",\n (pidx,),\n )\n timing = cursor.fetchone()[0]\n return timing if timing is not None else -1","def get_point_at(self, t):\n segment = self.get_segment_for_time(t)\n return segment.point_at(t)","def index_in_epoch(self):\n return self._index_in_epoch","def take_nth(n):\n def _take_nth_xducer(step):\n outer = {\"idx\": 0}\n def _take_nth_step(r=Missing, x=Missing):\n if r is Missing: return step()\n if x is Missing:\n return step(r)\n if outer[\"idx\"] % n:\n outer[\"idx\"] += 1\n return r\n else:\n outer[\"idx\"] += 1\n return step(r, x)\n return _take_nth_step\n return _take_nth_xducer","def get_info(index, n):\n return index/n, index%n","def get_day(time_index):\n return np.array(time_index.day).reshape(-1,1)","def get_next(current):\n return 0.5 * (current + n / current)","def take_second(info):\n return info[1]","def at(self, t, tol=None):\r\n return self.data[..., self.time.index_at(t)]","def getPositionKeyTime(self, index, keyIndex, view) -> float:\n ...","def get_first_timepoints(sj):\n print('> Get first timepoints {}'.format(sj))\n sj_parameters = pickle.load(open(jph(pfo_subjects_parameters, sj), 'r'))\n\n study = sj_parameters['study']\n category = sj_parameters['category']\n\n root_subject = jph(root_study_rabbits, 'A_data', study, category, sj)\n pfi_DWI_Eddi_corrected = jph(root_subject, 'z_tmp', 'z_DWI', '{}_DWI_eddy.nii.gz'.format(sj))\n\n im = nib.load(pfi_DWI_Eddi_corrected)\n\n im_new = set_new_data(im, new_data=im.get_data()[..., :S0_timepoints])\n\n pfi_only_S0 = jph(root_output, '{}_DWI_only_S0.nii.gz'.format(sj))\n nib.save(im_new, pfi_only_S0)","def T(self, point = -1):\n return self.solution('T', point)","def get_hour(time_index):\n return np.array(time_index.hour).reshape(-1,1)","def test_index_at_20101206():\r\n A = np.random.standard_normal(40)\r\n #negative t0\r\n TS_A = ts.TimeSeries(A, t0=-20, sampling_interval=2)\r\n npt.assert_equal(TS_A.time.index_at(TS_A.time), np.arange(40))\r\n #positive t0\r\n TS_A = ts.TimeSeries(A, t0=15, sampling_interval=2)\r\n npt.assert_equal(TS_A.time.index_at(TS_A.time), np.arange(40))\r\n #no t0\r\n TS_A = ts.TimeSeries(A, sampling_interval=2)\r\n npt.assert_equal(TS_A.time.index_at(TS_A.time), np.arange(40))","def range(self):\n return self.times[0], self.times[-1]","def get_nth_ast(self, n):\n return self.get_c_sect()[n]","def getSlicesPerTimepoint(self):\n\t\treturn self.slicesPerTimepoint","def get_specific_nc_timeindex(fname,\n time_value,\n time_varname='time'):\n\n assert isinstance(time_value, datetime.date)\n\n nc_fid = netCDF4.Dataset(fname, 'r')\n time_values = netCDF4.num2date(nc_fid.variables[time_varname][:],\n nc_fid.variables[time_varname].units,\n nc_fid.variables[time_varname].calendar)\n nearest_index = 0\n nearest_value = time_values[nearest_index]\n nearest_diff = time_difference(nearest_value, time_value)\n for idx, tvalue in enumerate(time_values):\n this_diff = time_difference(tvalue, time_value)\n if this_diff < nearest_diff:\n nearest_index = idx\n nearest_value = time_values[idx]\n nearest_diff = this_diff\n\n return nearest_index","def _tv_pointwise(data):\n return np.maximum(\n 0,\n np.ceil(\n (np.expand_dims(data.meeting_time - data.lag, -1) - np.arange(data.x.shape[0]))\n / data.lag\n ),\n )","def get_minute(time_index):\n return np.array(time_index.minute).reshape(-1,1)","def time_position(self):\n rt_most_pixel = None\n lf_most_pixel = None\n time_position = []\n min_time_len = None\n for i in range (len(np.unique(self.pd.objid))):\n trajec = self.dataset.trajec(self.dataset.keys[i])\n times = trajec.time_epoch_secs + trajec.time_epoch_nsecs / 1e9\n time_pos = np.vstack([times, trajec.position_x])\n time_position.append(time_pos)\n if min_time_len == None:\n min_time_len = len(times)\n elif min_time_len > len(times):\n min_time_len = len(times)\n pixels = np.unique(trajec.position_x)\n if rt_most_pixel ==None:\n rt_most_pixel = pixels[-1]\n elif rt_most_pixel < pixels[-1]:\n rt_most_pixel = pixels[-1]\n if lf_most_pixel ==None:\n lf_most_pixel = pixels[0]\n elif lf_most_pixel > pixels[0]:\n lf_most_pixel = pixels[0]\n print min_time_len\n print rt_most_pixel\n print lf_most_pixel\n print rt_most_pixel - lf_most_pixel\n return time_position, rt_most_pixel, lf_most_pixel","def oneTimepoint(timepoint):\n\tt = []\n\tfor vs in timepoint:\n\t\tt.append((timepoint.attrib.get('CollectionTime'), vs[0].text, vs[1].text))\n\treturn(t)","def second(self) -> int:\r\n return self._second","def _get_var_at_iter(self, n_iter):\n if self.schedule_dict is not None:\n # user specified schedule\n schedule = sorted(self.schedule_dict.items(), key=lambda x: x[0], reverse=True)\n for k, v in schedule:\n if n_iter >= k:\n return v\n return self.x_init\n else: # gradually decreasing schedule\n if self.drop_after_iters > 0:\n factor = 1 + (n_iter - 1) / self.drop_after_iters\n else:\n factor = 1\n\n if self.decrease_type == 'sqrt':\n return 1.0 * self.x_init / math.sqrt(factor)\n else:\n return 1.0 * self.x_init / factor","def getSegment(self, t: float, endBehavior: str = 'halt') -> Tuple[int,float]:\n if len(self.times)==0:\n raise ValueError(\"Empty trajectory\")\n if len(self.times)==1:\n return (-1,0)\n if t > self.times[-1]:\n if endBehavior == 'loop':\n try:\n t = t % self.times[-1]\n except ZeroDivisionError:\n t = 0\n else:\n return (len(self.milestones)-1,0)\n if t >= self.times[-1]:\n return (len(self.milestones)-1,0)\n if t <= self.times[0]:\n return (-1,0)\n i = bisect.bisect_right(self.times,t)\n p=i-1\n assert i > 0 and i < len(self.times),\"Invalid time index \"+str(t)+\" in \"+str(self.times)\n u=(t-self.times[p])/(self.times[i]-self.times[p])\n if i==0:\n if endBehavior == 'loop':\n t = t + self.times[-1]\n p = -2\n u=(t-self.times[p])/(self.times[-1]-self.times[p])\n else:\n return (-1,0)\n assert u >= 0 and u <= 1\n return (p,u)","def frame_to_time_point(time_point_of_first_video_frame, camera_frames_in_video, points_per_pulse, frame):\n return int(time_point_of_first_video_frame + (camera_frames_in_video[frame] * points_per_pulse))","def Temp(t):\n return 20 # Need to link to data","def find_time_idx(nc, needle):\n tm = nc.variables[\"time\"]\n tstr = tm.units.replace(\"days since \", \"\")\n t0 = datetime.datetime.strptime(tstr.split()[0], \"%Y-%m-%d\")\n cal360 = True if tm.calendar == \"360_day\" else False\n cal365 = True if tm.calendar == \"365_day\" else False\n times = tm[:]\n for i, time in enumerate(times):\n if cal360:\n time = time - 15\n years = time / 360\n months = (time % 360) / 30\n ts = datetime.datetime(t0.year + years, 1 + months, 1)\n elif cal365:\n years = int(time / 365)\n months = int((time % 365) / 30)\n ts = datetime.datetime(t0.year + years, 1 + months, 1)\n else:\n ts = t0 + datetime.timedelta(days=time)\n if ts.year == needle.year and ts.month == needle.month:\n print \"Returning: %s/%s for needle: %s\" % (i, len(times), needle)\n return i\n return None","def second(self) -> Index:\n warnings.warn(\n \"`second` will return int32 index instead of int 64 index in 4.0.0.\",\n FutureWarning,\n )\n return Index(self.to_series().dt.second)","def getLinIterTimes( self, var, index = 0 ):\n\n values = self.getLinIterData( var, index )\n return values[1]","def setSlicesPerTimepoint(self, n):\n\t\tassert n > 0, \"Slices per timepoint needs to be greater than 0\"\n\t\tprint \"Setting slices per timepoint to \", n\n\t\tself.slicesPerTimepoint = n\n\t\tself.z = n\n\t\tself.readers = []","def timeStep(self):\n return self.params['h']","def get_tmpT(T_e, i, tmpN_t):\n if i == 0:\n print \"Solution converged into an unphysical state. \",\\\n \"Choose a better initial guess r_0.\"\n else:\n tmpT = np.logspace(np.log10(T_e[-i-1]), np.log10(T_e[-i]), num= tmpN_t,\n endpoint = True)\n return tmpT","def time_based(t, eta_init, last_eta, d = 0.01):\n return last_eta/(1+d*t)","def nth(iterable, n, default=None):\n return next(islice(iterable, n, None), default)","def nth(iterable, n, default=None):\n return next(islice(iterable, n, None), default)","def nth(iterable, n, default=None):\n return next(islice(iterable, n, None), default)","def to_timestamp(index, base_dt, fps=4):\n ts = time.mktime(base_dt.timetuple())\n return ts + index * (1.0 / fps)","def __getitem__(self, i): #i is index given by the caller\n l_self = len(self)\n if i >= self.times * l_self:\n raise IndexError (\"Circle object goes around %d times\" % (self.times)) #raise IndexError\n return self.data[i % l_self] # return answer","def get_time_ceiling(time, data):\n if time >= data.index.max():\n return data.iloc[-1]\n elif time <= data.index.min():\n return data.iloc[0]\n return data[str(time):].iloc[0]","def getTimes():","def getTimes():","def getTimes():","def litres(time):\n return int(time / 2)","def seperate_time(sp):\n\n\tind = np.where(sp > 0)[0]\n\treturn (ind)","def n(self):\n return self._time_axis.size","def get_nth_filepath(self, n):\n return self.get_filepaths()[n] if n < len(self.get_filepaths()) else None","def nth(n, iterable, default = None):\n return next(islice(iterable, n, None), default)","def traj_nslice (u,teq,tsample) :\n # get the number of frames in the slice (http://stackoverflow.com/a/7223557)\n traj_slice = u.trajectory[teq::tsample]\n return sum(1 for _ in traj_slice)","def traj_nslice (u,teq,tsample) :\n # get the number of frames in the slice (http://stackoverflow.com/a/7223557)\n traj_slice = u.trajectory[teq::tsample]\n return sum(1 for _ in traj_slice)","def spark_index(n):\n return int(round((clamp(n) - minimum) * coefficient))","def __getitem__(self, index):\n return self._timeseriesData[index]","def _get_time(self, sec, nsec):\n return sec + nsec / (10**9)","def get_time_index(self, month, year):\n return month + 12 * (year - self._first_valid_date.year) - 1","def get_time_delta(n):\n return datetime.timedelta(days=n)","def ricker(dt, pt):\n nt = int(2 * pt / dt)\n c = np.zeros(nt)\n t0 = pt / dt\n a_ricker = 4 / pt\n\n for it in range(0, nt):\n t = ((it + 1) - t0) * dt\n c[it] = -2 * a_ricker * t * math.exp(-(a_ricker * t) ** 2)\n\n return c","def get_element(self, index):\n original_index = index\n if index < 0:\n index = self.size + index\n if index >= self.size or index < 0:\n raise IndexError(\n 'index %i is out of range for SeriesAxis with size %i'\n % (original_index, self.size)\n )\n return self.start + self.step * index","def __getitem__(self, i):\n return self.__tiers[i]","def line_segment(t, # Array of times for each position\n t_now # Current time (float)\n ):\n i = np.argwhere(t > t_now)\n if len(i) > 0:\n if i[0] != 0: # if the current time is not less than the starting time\n segment_starting_index = i[0][0] - 1\n else:\n segment_starting_index = 0\n\n segment_end_index = i[0][0]\n\n else: # if the current time is more than the last point (destination) time\n segment_starting_index = t.shape[0]\n segment_end_index = t.shape[0]\n\n return segment_starting_index, segment_end_index","def nth_to_last2(head, k):\n if head is None:\n return 0\n i = nth_to_last2(head.next, k) + 1\n if i == k:\n print(head.data)\n return i","def get_special_point(power,events,borders,eventName,numericValue):\n event_consider = events[events['eventName']==eventName].reset_index(drop=True)\n #around turn_on\n i = 0 \n count = 0\n event_index = []\n while(i<len(event_consider)):\n date = time.mktime(datetime.strptime(event_consider['time'][i], \"%Y-%m-%d %H:%M:%S\").timetuple())\n start = str(datetime.fromtimestamp(date-borders[0]))\n end = str(datetime.fromtimestamp(date+borders[1]))\n serie = Series.from_array(power[(power['time']>=start)&(power['time']<=end)]['value'])\n if len(serie)>0:\n event_index.append(serie.index[int(len(serie)/2)])\n count += 1\n i += 1\n print(\"number of\", eventName ,\"in groudtruth and power=\",count)\n return event_index,[numericValue]*len(event_index)","def nskip(self, date, time0=None):\n time0 = self.time0 if time0 is None else Time(time0, scale='utc')\n dt = Time(date, scale='utc') - time0\n nskip = int(round((dt / self.dtsample / self.setsize)\n .to(u.dimensionless_unscaled)))\n return nskip","def get_last(t_, w_):\n return t_ - tf.constant(1)","def _event_arrival_path(path, n, e_0=0):\n # if e_0 is None:\n # the entry time of the first event\n\n if n > 0:\n e = e_0 + path.tasks[0].in_event_model.delta_plus(n + 1)\n elif n < 0:\n e = e_0 - path.tasks[0].in_event_model.delta_min(-n + 1)\n else:\n e = 0 # same event, so the difference is 0\n\n return e","def time_step(self):\n return self._time_step","def time_function(t):\n\n omega = np.pi\n return np.sin(omega * t) + np.sin(10 * omega * t) + np.sin(20 * omega * t)","def return_pos_index(self, index, tpos, window_size):\r\n maximum = min(len(self.data), index+(tpos//window_size)+1) # since non-inclusive\r\n return np.random.randint(index, maximum)","def get_time(self):\n start=''\n end=''\n time=''\n times=self.times\n print(times[self.istep])\n if self.istep > 0:\n start=ncEarth.beginstr % times[self.istep].isoformat()\n\n\n if self.istep < len(times)-2:\n end = ncEarth.endstr % times[self.istep+1].isoformat()\n\n if start is not '' or end is not '':\n time=ncEarth.timestr % {'begin':start,'end':end}\n\n return time","def time_callback(from_index, to_index):\r\n # Convert from routing variable Index to time matrix NodeIndex.\r\n from_node = manager.IndexToNode(from_index)\r\n to_node = manager.IndexToNode(to_index)\r\n return data['time_matrix'][from_node][to_node]","def get_tmid(l):\n return Time(l['date-obs'], format='fits') + l['exptime']/2*u.s","def first_touch_timestamp(self):\n return self.touches[:1].index[0]"],"string":"[\n \"def nthPersonGetsNthSeat(self, n: int) -> float:\\n if n == 1:\\n return 1.0\\n\\n return 1 / 2\",\n \"def get_second(time_index):\\n return np.array(time_index.second).reshape(-1,1)\",\n \"def get_times_slice(self, index, next_index):\\n next_index = tf.minimum(next_index, self.Nt)\\n indices = tf.range(index, next_index)\\n return tf.gather(self.times, indices, axis=0)\",\n \"def time(n):\\n steps = 3 + math.ceil(n/5.0)*2\\n return steps\",\n \"def nth(f, *N):\\n return dmp_ground_nth(f.rep, N, f.lev, f.dom)\",\n \"def get_t(self, n, c):\\n t = 1\\n while t * n + t * t * n * n < 2 * c:\\n t += 1\\n return t - 1\",\n \"def at(self, t):\\n return self.start + (self.end - self.start) * t\",\n \"def _ith_point(self, i):\\n if self.start is S.NegativeInfinity:\\n initial = self.stop\\n else:\\n initial = self.start\\n\\n if self.start is S.NegativeInfinity:\\n step = -1\\n else:\\n step = 1\\n\\n return initial + i*step\",\n \"def __getitem__(self, index: datetime.time) -> float:\\n\\n # If the index is in the profile, return the index.\\n if index in self._profile:\\n return self._profile[index]\\n\\n # If the index is not in the profile, then the closest value needs to be\\n # determined. If there is a tie, this does not matter.\\n delta_t_to_t_map = {\\n (\\n abs(\\n time.hour * 3600\\n + time.minute * 60\\n + time.second\\n - (index.hour * 3600 + index.minute * 60 + index.second)\\n )\\n ): time\\n for time in self._profile\\n }\\n return self._profile[delta_t_to_t_map[min(delta_t_to_t_map)]]\",\n \"def Ni_find(t):\\r\\n return ep(t) - 1\",\n \"def time_to_position(tracks, point):\\n\\n index1 = [index for index, track_point in enumerate(tracks[0]) if track_point == point][0]\\n index2 = [index for index, track_point in enumerate(tracks[1]) if track_point == point][0]\\n\\n # We add one to the length of each track as 0,0 to first point is missing from the track data\\n return index1 + 1 + index2 + 1\",\n \"def ntimestep(self):\\n if self._ntimestep is None:\\n self._ntimestep = self.get_data_ntimestep()\\n\\n return self._ntimestep\",\n \"def window_index_time(t,windowsize,overlap):\\r\\n \\r\\n try:\\r\\n t=t.tolist()\\r\\n except:\\r\\n t=t\\r\\n \\r\\n t1=t[0]\\r\\n t2=t1 + timedelta(seconds=windowsize)\\r\\n pt1=[0]\\r\\n pt2=[othertime.findNearest(t2,t)]\\r\\n while t2 < t[-1]:\\r\\n t1 = t2 - timedelta(seconds=overlap)\\r\\n t2 = t1 + timedelta(seconds=windowsize)\\r\\n\\r\\n pt1.append(othertime.findNearest(t1,t))\\r\\n pt2.append(othertime.findNearest(t2,t))\\r\\n \\r\\n return pt1, pt2\",\n \"def get_time_to_point(self, point):\\n dist = 0\\n for node in self.order_hist:\\n if point == node:\\n return dist\\n dist += 1\\n return -1\",\n \"def get_nanosecond(time_index):\\n return np.array(time_index.nanosecond).reshape(-1,1)\",\n \"def nth(n, seq):\\n try:\\n return seq[n]\\n except TypeError:\\n return next(itertools.islice(seq, n, None))\",\n \"def nth(iterable, index):\\n return next(itertools.islice(iterable, index, None))\",\n \"def next_change(self, t=None):\\n if t is None:\\n t = self.engine.get_now()\\n t -= self.initTime\\n\\n p = float(self.period) / POINTS_PER_CYCLE\\n t2 = math.floor(t / p) * p + p\\n\\n t2 += self.initTime\\n\\n return t2\",\n \"def target(self, time, points, dt, num_way):\\n start_index = min(int(time / dt), num_way - 1)\\n end_index = min(start_index + 1, num_way - 1)\\n start_point = points[start_index]\\n end_point = points[end_index]\\n fraction = float(time % dt) / dt\\n return linear_interpolation_two_points(start_point, end_point, fraction).reshape(3)\",\n \"def get_complex_last_elf(n):\\n if math.floor(math.log(n, 3)) == math.ceil(math.log(n, 3)):\\n return n\\n prev_log3 = 3 ** int(math.floor(math.log(n, 3)))\\n next_log3 = prev_log3 + 1\\n # print 'log3', prev_log3, next_log3\\n midpoint = int((next_log3 - prev_log3) / 2)\\n index = n - prev_log3\\n # print 'midpoint index', midpoint\\n # print 'midpoint', prev_log3 + midpoint\\n # print 'index', index\\n if index <= midpoint:\\n # print 'it\\\\'s the straight index'\\n return index\\n else:\\n # print 'it\\\\'s the index times 2 minus half the distance'\\n return index * 2 - midpoint\",\n \"def _getIndexAtTime(self, startTime: float) -> int:\\n return round(startTime * self.frameRate * self.sampleWidth)\",\n \"def time(self):\\r\\n return self._idx\",\n \"def timestep_idx(self, timestep):\\n timestep = pd.to_datetime(timestep)\\n idx = np.where(self.time_index == timestep)[0][0]\\n\\n return idx\",\n \"def getPivotPointKeyTime(self, index, view) -> float:\\n ...\",\n \"def time(self, k):\\n \\n it = Historial.__getitem__(self, k)\\n if it != None:\\n return it[0]\\n else:\\n return None\",\n \"def getWeightTime(self, index):\\r\\n\\t\\treturn None\",\n \"def GetPointForLabel(points):\\n # TODO: find the last point at a minute boundary\\n return points[-1]\",\n \"def poly_nth(f, n):\\n if n < 0 or n > len(f)-1:\\n raise IndexError\\n else:\\n return f[zzx_degree(f)-n]\",\n \"def findNthPlayerFromSeat(self, seat, n):\\n\\t\\tfor i in range(1,7):\\n\\t\\t\\tindex = (seat + i) % 6\\n\\t\\t\\tif self.playerList[index] != None:\\n\\t\\t\\t\\tif n > 1:\\n\\t\\t\\t\\t\\tn = n - 1\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\treturn (self.playerList[index], index)\",\n \"def get_timing(pidx):\\n pgconn = get_dbconn(\\\"mesosite\\\")\\n cursor = pgconn.cursor()\\n cursor.execute(\\n \\\"SELECT avg(timing) from autoplot_timing where appid = %s \\\"\\n \\\"and valid > (now() - '7 days'::interval)\\\",\\n (pidx,),\\n )\\n timing = cursor.fetchone()[0]\\n return timing if timing is not None else -1\",\n \"def get_point_at(self, t):\\n segment = self.get_segment_for_time(t)\\n return segment.point_at(t)\",\n \"def index_in_epoch(self):\\n return self._index_in_epoch\",\n \"def take_nth(n):\\n def _take_nth_xducer(step):\\n outer = {\\\"idx\\\": 0}\\n def _take_nth_step(r=Missing, x=Missing):\\n if r is Missing: return step()\\n if x is Missing:\\n return step(r)\\n if outer[\\\"idx\\\"] % n:\\n outer[\\\"idx\\\"] += 1\\n return r\\n else:\\n outer[\\\"idx\\\"] += 1\\n return step(r, x)\\n return _take_nth_step\\n return _take_nth_xducer\",\n \"def get_info(index, n):\\n return index/n, index%n\",\n \"def get_day(time_index):\\n return np.array(time_index.day).reshape(-1,1)\",\n \"def get_next(current):\\n return 0.5 * (current + n / current)\",\n \"def take_second(info):\\n return info[1]\",\n \"def at(self, t, tol=None):\\r\\n return self.data[..., self.time.index_at(t)]\",\n \"def getPositionKeyTime(self, index, keyIndex, view) -> float:\\n ...\",\n \"def get_first_timepoints(sj):\\n print('> Get first timepoints {}'.format(sj))\\n sj_parameters = pickle.load(open(jph(pfo_subjects_parameters, sj), 'r'))\\n\\n study = sj_parameters['study']\\n category = sj_parameters['category']\\n\\n root_subject = jph(root_study_rabbits, 'A_data', study, category, sj)\\n pfi_DWI_Eddi_corrected = jph(root_subject, 'z_tmp', 'z_DWI', '{}_DWI_eddy.nii.gz'.format(sj))\\n\\n im = nib.load(pfi_DWI_Eddi_corrected)\\n\\n im_new = set_new_data(im, new_data=im.get_data()[..., :S0_timepoints])\\n\\n pfi_only_S0 = jph(root_output, '{}_DWI_only_S0.nii.gz'.format(sj))\\n nib.save(im_new, pfi_only_S0)\",\n \"def T(self, point = -1):\\n return self.solution('T', point)\",\n \"def get_hour(time_index):\\n return np.array(time_index.hour).reshape(-1,1)\",\n \"def test_index_at_20101206():\\r\\n A = np.random.standard_normal(40)\\r\\n #negative t0\\r\\n TS_A = ts.TimeSeries(A, t0=-20, sampling_interval=2)\\r\\n npt.assert_equal(TS_A.time.index_at(TS_A.time), np.arange(40))\\r\\n #positive t0\\r\\n TS_A = ts.TimeSeries(A, t0=15, sampling_interval=2)\\r\\n npt.assert_equal(TS_A.time.index_at(TS_A.time), np.arange(40))\\r\\n #no t0\\r\\n TS_A = ts.TimeSeries(A, sampling_interval=2)\\r\\n npt.assert_equal(TS_A.time.index_at(TS_A.time), np.arange(40))\",\n \"def range(self):\\n return self.times[0], self.times[-1]\",\n \"def get_nth_ast(self, n):\\n return self.get_c_sect()[n]\",\n \"def getSlicesPerTimepoint(self):\\n\\t\\treturn self.slicesPerTimepoint\",\n \"def get_specific_nc_timeindex(fname,\\n time_value,\\n time_varname='time'):\\n\\n assert isinstance(time_value, datetime.date)\\n\\n nc_fid = netCDF4.Dataset(fname, 'r')\\n time_values = netCDF4.num2date(nc_fid.variables[time_varname][:],\\n nc_fid.variables[time_varname].units,\\n nc_fid.variables[time_varname].calendar)\\n nearest_index = 0\\n nearest_value = time_values[nearest_index]\\n nearest_diff = time_difference(nearest_value, time_value)\\n for idx, tvalue in enumerate(time_values):\\n this_diff = time_difference(tvalue, time_value)\\n if this_diff < nearest_diff:\\n nearest_index = idx\\n nearest_value = time_values[idx]\\n nearest_diff = this_diff\\n\\n return nearest_index\",\n \"def _tv_pointwise(data):\\n return np.maximum(\\n 0,\\n np.ceil(\\n (np.expand_dims(data.meeting_time - data.lag, -1) - np.arange(data.x.shape[0]))\\n / data.lag\\n ),\\n )\",\n \"def get_minute(time_index):\\n return np.array(time_index.minute).reshape(-1,1)\",\n \"def time_position(self):\\n rt_most_pixel = None\\n lf_most_pixel = None\\n time_position = []\\n min_time_len = None\\n for i in range (len(np.unique(self.pd.objid))):\\n trajec = self.dataset.trajec(self.dataset.keys[i])\\n times = trajec.time_epoch_secs + trajec.time_epoch_nsecs / 1e9\\n time_pos = np.vstack([times, trajec.position_x])\\n time_position.append(time_pos)\\n if min_time_len == None:\\n min_time_len = len(times)\\n elif min_time_len > len(times):\\n min_time_len = len(times)\\n pixels = np.unique(trajec.position_x)\\n if rt_most_pixel ==None:\\n rt_most_pixel = pixels[-1]\\n elif rt_most_pixel < pixels[-1]:\\n rt_most_pixel = pixels[-1]\\n if lf_most_pixel ==None:\\n lf_most_pixel = pixels[0]\\n elif lf_most_pixel > pixels[0]:\\n lf_most_pixel = pixels[0]\\n print min_time_len\\n print rt_most_pixel\\n print lf_most_pixel\\n print rt_most_pixel - lf_most_pixel\\n return time_position, rt_most_pixel, lf_most_pixel\",\n \"def oneTimepoint(timepoint):\\n\\tt = []\\n\\tfor vs in timepoint:\\n\\t\\tt.append((timepoint.attrib.get('CollectionTime'), vs[0].text, vs[1].text))\\n\\treturn(t)\",\n \"def second(self) -> int:\\r\\n return self._second\",\n \"def _get_var_at_iter(self, n_iter):\\n if self.schedule_dict is not None:\\n # user specified schedule\\n schedule = sorted(self.schedule_dict.items(), key=lambda x: x[0], reverse=True)\\n for k, v in schedule:\\n if n_iter >= k:\\n return v\\n return self.x_init\\n else: # gradually decreasing schedule\\n if self.drop_after_iters > 0:\\n factor = 1 + (n_iter - 1) / self.drop_after_iters\\n else:\\n factor = 1\\n\\n if self.decrease_type == 'sqrt':\\n return 1.0 * self.x_init / math.sqrt(factor)\\n else:\\n return 1.0 * self.x_init / factor\",\n \"def getSegment(self, t: float, endBehavior: str = 'halt') -> Tuple[int,float]:\\n if len(self.times)==0:\\n raise ValueError(\\\"Empty trajectory\\\")\\n if len(self.times)==1:\\n return (-1,0)\\n if t > self.times[-1]:\\n if endBehavior == 'loop':\\n try:\\n t = t % self.times[-1]\\n except ZeroDivisionError:\\n t = 0\\n else:\\n return (len(self.milestones)-1,0)\\n if t >= self.times[-1]:\\n return (len(self.milestones)-1,0)\\n if t <= self.times[0]:\\n return (-1,0)\\n i = bisect.bisect_right(self.times,t)\\n p=i-1\\n assert i > 0 and i < len(self.times),\\\"Invalid time index \\\"+str(t)+\\\" in \\\"+str(self.times)\\n u=(t-self.times[p])/(self.times[i]-self.times[p])\\n if i==0:\\n if endBehavior == 'loop':\\n t = t + self.times[-1]\\n p = -2\\n u=(t-self.times[p])/(self.times[-1]-self.times[p])\\n else:\\n return (-1,0)\\n assert u >= 0 and u <= 1\\n return (p,u)\",\n \"def frame_to_time_point(time_point_of_first_video_frame, camera_frames_in_video, points_per_pulse, frame):\\n return int(time_point_of_first_video_frame + (camera_frames_in_video[frame] * points_per_pulse))\",\n \"def Temp(t):\\n return 20 # Need to link to data\",\n \"def find_time_idx(nc, needle):\\n tm = nc.variables[\\\"time\\\"]\\n tstr = tm.units.replace(\\\"days since \\\", \\\"\\\")\\n t0 = datetime.datetime.strptime(tstr.split()[0], \\\"%Y-%m-%d\\\")\\n cal360 = True if tm.calendar == \\\"360_day\\\" else False\\n cal365 = True if tm.calendar == \\\"365_day\\\" else False\\n times = tm[:]\\n for i, time in enumerate(times):\\n if cal360:\\n time = time - 15\\n years = time / 360\\n months = (time % 360) / 30\\n ts = datetime.datetime(t0.year + years, 1 + months, 1)\\n elif cal365:\\n years = int(time / 365)\\n months = int((time % 365) / 30)\\n ts = datetime.datetime(t0.year + years, 1 + months, 1)\\n else:\\n ts = t0 + datetime.timedelta(days=time)\\n if ts.year == needle.year and ts.month == needle.month:\\n print \\\"Returning: %s/%s for needle: %s\\\" % (i, len(times), needle)\\n return i\\n return None\",\n \"def second(self) -> Index:\\n warnings.warn(\\n \\\"`second` will return int32 index instead of int 64 index in 4.0.0.\\\",\\n FutureWarning,\\n )\\n return Index(self.to_series().dt.second)\",\n \"def getLinIterTimes( self, var, index = 0 ):\\n\\n values = self.getLinIterData( var, index )\\n return values[1]\",\n \"def setSlicesPerTimepoint(self, n):\\n\\t\\tassert n > 0, \\\"Slices per timepoint needs to be greater than 0\\\"\\n\\t\\tprint \\\"Setting slices per timepoint to \\\", n\\n\\t\\tself.slicesPerTimepoint = n\\n\\t\\tself.z = n\\n\\t\\tself.readers = []\",\n \"def timeStep(self):\\n return self.params['h']\",\n \"def get_tmpT(T_e, i, tmpN_t):\\n if i == 0:\\n print \\\"Solution converged into an unphysical state. \\\",\\\\\\n \\\"Choose a better initial guess r_0.\\\"\\n else:\\n tmpT = np.logspace(np.log10(T_e[-i-1]), np.log10(T_e[-i]), num= tmpN_t,\\n endpoint = True)\\n return tmpT\",\n \"def time_based(t, eta_init, last_eta, d = 0.01):\\n return last_eta/(1+d*t)\",\n \"def nth(iterable, n, default=None):\\n return next(islice(iterable, n, None), default)\",\n \"def nth(iterable, n, default=None):\\n return next(islice(iterable, n, None), default)\",\n \"def nth(iterable, n, default=None):\\n return next(islice(iterable, n, None), default)\",\n \"def to_timestamp(index, base_dt, fps=4):\\n ts = time.mktime(base_dt.timetuple())\\n return ts + index * (1.0 / fps)\",\n \"def __getitem__(self, i): #i is index given by the caller\\n l_self = len(self)\\n if i >= self.times * l_self:\\n raise IndexError (\\\"Circle object goes around %d times\\\" % (self.times)) #raise IndexError\\n return self.data[i % l_self] # return answer\",\n \"def get_time_ceiling(time, data):\\n if time >= data.index.max():\\n return data.iloc[-1]\\n elif time <= data.index.min():\\n return data.iloc[0]\\n return data[str(time):].iloc[0]\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def litres(time):\\n return int(time / 2)\",\n \"def seperate_time(sp):\\n\\n\\tind = np.where(sp > 0)[0]\\n\\treturn (ind)\",\n \"def n(self):\\n return self._time_axis.size\",\n \"def get_nth_filepath(self, n):\\n return self.get_filepaths()[n] if n < len(self.get_filepaths()) else None\",\n \"def nth(n, iterable, default = None):\\n return next(islice(iterable, n, None), default)\",\n \"def traj_nslice (u,teq,tsample) :\\n # get the number of frames in the slice (http://stackoverflow.com/a/7223557)\\n traj_slice = u.trajectory[teq::tsample]\\n return sum(1 for _ in traj_slice)\",\n \"def traj_nslice (u,teq,tsample) :\\n # get the number of frames in the slice (http://stackoverflow.com/a/7223557)\\n traj_slice = u.trajectory[teq::tsample]\\n return sum(1 for _ in traj_slice)\",\n \"def spark_index(n):\\n return int(round((clamp(n) - minimum) * coefficient))\",\n \"def __getitem__(self, index):\\n return self._timeseriesData[index]\",\n \"def _get_time(self, sec, nsec):\\n return sec + nsec / (10**9)\",\n \"def get_time_index(self, month, year):\\n return month + 12 * (year - self._first_valid_date.year) - 1\",\n \"def get_time_delta(n):\\n return datetime.timedelta(days=n)\",\n \"def ricker(dt, pt):\\n nt = int(2 * pt / dt)\\n c = np.zeros(nt)\\n t0 = pt / dt\\n a_ricker = 4 / pt\\n\\n for it in range(0, nt):\\n t = ((it + 1) - t0) * dt\\n c[it] = -2 * a_ricker * t * math.exp(-(a_ricker * t) ** 2)\\n\\n return c\",\n \"def get_element(self, index):\\n original_index = index\\n if index < 0:\\n index = self.size + index\\n if index >= self.size or index < 0:\\n raise IndexError(\\n 'index %i is out of range for SeriesAxis with size %i'\\n % (original_index, self.size)\\n )\\n return self.start + self.step * index\",\n \"def __getitem__(self, i):\\n return self.__tiers[i]\",\n \"def line_segment(t, # Array of times for each position\\n t_now # Current time (float)\\n ):\\n i = np.argwhere(t > t_now)\\n if len(i) > 0:\\n if i[0] != 0: # if the current time is not less than the starting time\\n segment_starting_index = i[0][0] - 1\\n else:\\n segment_starting_index = 0\\n\\n segment_end_index = i[0][0]\\n\\n else: # if the current time is more than the last point (destination) time\\n segment_starting_index = t.shape[0]\\n segment_end_index = t.shape[0]\\n\\n return segment_starting_index, segment_end_index\",\n \"def nth_to_last2(head, k):\\n if head is None:\\n return 0\\n i = nth_to_last2(head.next, k) + 1\\n if i == k:\\n print(head.data)\\n return i\",\n \"def get_special_point(power,events,borders,eventName,numericValue):\\n event_consider = events[events['eventName']==eventName].reset_index(drop=True)\\n #around turn_on\\n i = 0 \\n count = 0\\n event_index = []\\n while(i<len(event_consider)):\\n date = time.mktime(datetime.strptime(event_consider['time'][i], \\\"%Y-%m-%d %H:%M:%S\\\").timetuple())\\n start = str(datetime.fromtimestamp(date-borders[0]))\\n end = str(datetime.fromtimestamp(date+borders[1]))\\n serie = Series.from_array(power[(power['time']>=start)&(power['time']<=end)]['value'])\\n if len(serie)>0:\\n event_index.append(serie.index[int(len(serie)/2)])\\n count += 1\\n i += 1\\n print(\\\"number of\\\", eventName ,\\\"in groudtruth and power=\\\",count)\\n return event_index,[numericValue]*len(event_index)\",\n \"def nskip(self, date, time0=None):\\n time0 = self.time0 if time0 is None else Time(time0, scale='utc')\\n dt = Time(date, scale='utc') - time0\\n nskip = int(round((dt / self.dtsample / self.setsize)\\n .to(u.dimensionless_unscaled)))\\n return nskip\",\n \"def get_last(t_, w_):\\n return t_ - tf.constant(1)\",\n \"def _event_arrival_path(path, n, e_0=0):\\n # if e_0 is None:\\n # the entry time of the first event\\n\\n if n > 0:\\n e = e_0 + path.tasks[0].in_event_model.delta_plus(n + 1)\\n elif n < 0:\\n e = e_0 - path.tasks[0].in_event_model.delta_min(-n + 1)\\n else:\\n e = 0 # same event, so the difference is 0\\n\\n return e\",\n \"def time_step(self):\\n return self._time_step\",\n \"def time_function(t):\\n\\n omega = np.pi\\n return np.sin(omega * t) + np.sin(10 * omega * t) + np.sin(20 * omega * t)\",\n \"def return_pos_index(self, index, tpos, window_size):\\r\\n maximum = min(len(self.data), index+(tpos//window_size)+1) # since non-inclusive\\r\\n return np.random.randint(index, maximum)\",\n \"def get_time(self):\\n start=''\\n end=''\\n time=''\\n times=self.times\\n print(times[self.istep])\\n if self.istep > 0:\\n start=ncEarth.beginstr % times[self.istep].isoformat()\\n\\n\\n if self.istep < len(times)-2:\\n end = ncEarth.endstr % times[self.istep+1].isoformat()\\n\\n if start is not '' or end is not '':\\n time=ncEarth.timestr % {'begin':start,'end':end}\\n\\n return time\",\n \"def time_callback(from_index, to_index):\\r\\n # Convert from routing variable Index to time matrix NodeIndex.\\r\\n from_node = manager.IndexToNode(from_index)\\r\\n to_node = manager.IndexToNode(to_index)\\r\\n return data['time_matrix'][from_node][to_node]\",\n \"def get_tmid(l):\\n return Time(l['date-obs'], format='fits') + l['exptime']/2*u.s\",\n \"def first_touch_timestamp(self):\\n return self.touches[:1].index[0]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6113835","0.6054137","0.5898435","0.58786285","0.58263016","0.57462263","0.5740125","0.5694311","0.5676445","0.56450284","0.5632503","0.55841124","0.5574055","0.55318683","0.55112934","0.5497918","0.54749393","0.54705596","0.5468096","0.5458759","0.5441463","0.54392374","0.5435774","0.5422698","0.5416039","0.54121935","0.5392133","0.5390978","0.5365546","0.53651","0.5364531","0.5342265","0.5339246","0.5334274","0.53305435","0.5305823","0.5285447","0.5275633","0.5270471","0.52596974","0.52537596","0.52521724","0.5246544","0.5224158","0.52199453","0.5204427","0.5194786","0.51843464","0.51833075","0.51819235","0.51737696","0.51736444","0.5163691","0.5162897","0.51611245","0.5159491","0.51531476","0.51422167","0.5137233","0.5133266","0.5131026","0.51236296","0.5119003","0.51169413","0.51169413","0.51169413","0.51143396","0.5113877","0.510628","0.510267","0.510267","0.510267","0.50987107","0.5090174","0.50837684","0.50824183","0.5066076","0.50634974","0.50634974","0.5062952","0.5057905","0.50560784","0.5053506","0.5032898","0.50262755","0.5022831","0.5020925","0.50172293","0.5016397","0.50088054","0.50060874","0.50030273","0.5000733","0.49781168","0.49705586","0.49678513","0.49663514","0.49621087","0.49595273","0.49566534"],"string":"[\n \"0.6113835\",\n \"0.6054137\",\n \"0.5898435\",\n \"0.58786285\",\n \"0.58263016\",\n \"0.57462263\",\n \"0.5740125\",\n \"0.5694311\",\n \"0.5676445\",\n \"0.56450284\",\n \"0.5632503\",\n \"0.55841124\",\n \"0.5574055\",\n \"0.55318683\",\n \"0.55112934\",\n \"0.5497918\",\n \"0.54749393\",\n \"0.54705596\",\n \"0.5468096\",\n \"0.5458759\",\n \"0.5441463\",\n \"0.54392374\",\n \"0.5435774\",\n \"0.5422698\",\n \"0.5416039\",\n \"0.54121935\",\n \"0.5392133\",\n \"0.5390978\",\n \"0.5365546\",\n \"0.53651\",\n \"0.5364531\",\n \"0.5342265\",\n \"0.5339246\",\n \"0.5334274\",\n \"0.53305435\",\n \"0.5305823\",\n \"0.5285447\",\n \"0.5275633\",\n \"0.5270471\",\n \"0.52596974\",\n \"0.52537596\",\n \"0.52521724\",\n \"0.5246544\",\n \"0.5224158\",\n \"0.52199453\",\n \"0.5204427\",\n \"0.5194786\",\n \"0.51843464\",\n \"0.51833075\",\n \"0.51819235\",\n \"0.51737696\",\n \"0.51736444\",\n \"0.5163691\",\n \"0.5162897\",\n \"0.51611245\",\n \"0.5159491\",\n \"0.51531476\",\n \"0.51422167\",\n \"0.5137233\",\n \"0.5133266\",\n \"0.5131026\",\n \"0.51236296\",\n \"0.5119003\",\n \"0.51169413\",\n \"0.51169413\",\n \"0.51169413\",\n \"0.51143396\",\n \"0.5113877\",\n \"0.510628\",\n \"0.510267\",\n \"0.510267\",\n \"0.510267\",\n \"0.50987107\",\n \"0.5090174\",\n \"0.50837684\",\n \"0.50824183\",\n \"0.5066076\",\n \"0.50634974\",\n \"0.50634974\",\n \"0.5062952\",\n \"0.5057905\",\n \"0.50560784\",\n \"0.5053506\",\n \"0.5032898\",\n \"0.50262755\",\n \"0.5022831\",\n \"0.5020925\",\n \"0.50172293\",\n \"0.5016397\",\n \"0.50088054\",\n \"0.50060874\",\n \"0.50030273\",\n \"0.5000733\",\n \"0.49781168\",\n \"0.49705586\",\n \"0.49678513\",\n \"0.49663514\",\n \"0.49621087\",\n \"0.49595273\",\n \"0.49566534\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59078765"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":94992,"cells":{"query":{"kind":"string","value":"Returns the (x,y,z) dimensions of the datasets this dataunit contains"},"document":{"kind":"string","value":"def getDimensions(self):\n\t\tprint \"Returning\",self.x,self.y,self.slicesPerTimepoint\n\t\treturn (self.x, self.y, self.slicesPerTimepoint)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getDimensions():","def dimensions():","def get_data_dimensions(self):\n return image_utils.convert_shape_indexing(self._get_data_dimensions_rc(),\"rc\",self.image_indexing)","def get_dimensions(self):\r\n x = []\r\n y = []\r\n z = []\r\n for i in self.verts:\r\n x.append(i[0])\r\n y.append(i[1])\r\n z.append(i[2])\r\n\r\n x.append(abs(min(x)))\r\n y.append(abs(min(y)))\r\n z.append(abs(min(z)))\r\n\r\n return max(x), max(y), max(z)","def dims(self) -> tuple[str, str]:\n # if self.dim0 is not None:\n return self.y_dim, self.x_dim","def get_num_dimensions(self):\n dimensions = self.data.shape\n return dimensions[1]","def dims(self):\n return self.v.dims() # TODO: check (empty? etc)\n #return self.t.shape # TODO: check (empty? etc)\n # TODO: convert to tuple? here / in varset?","def dataDimensions(data):\n logging.info('Number of rows of data: %s' % len(data))\n logging.info('Number of columns of data: %s' % len(data[1]))","def dimensions(self) -> int:\n return pulumi.get(self, \"dimensions\")","def dims(self):\n return self[0].dims","def N(self):\n return self._dimensions","def get_data_dim(self):\n return self.data_dim","def dimension(self):\n\t\treturn self.d","def get_dimensions(self):\n return self.lon_arr.shape","def get_data_dims(self):\n return [len(self.tps)] + self.get_shape()[1:]","def get_dimension_length(self):\n pass","def getNumDimensions(self):\n return len(self.di.keys())","def getDimensions(self):\n return self._majax, self._minax, self._pa","def size(self):\n\t\treturn self.dims","def dimension(self):\n return 3*self.genus - 3 + self.n","def dimension(self) -> float:\n return self._dimensions","def dimension(self):","def dimensions(self) -> typing.Tuple[int, int]:\n dimensions = self.data[2]\n dimensions = re.findall(r'(\\d+)\\s+x\\s+(\\d+)\\s+M', dimensions.replace('-', '0'))\n return dimensions[0] if dimensions else (0, 0)","def dim(self):\n return self._d","def dimension(self):\n return len(self.qubit_values)","def dim(self):\n\t\treturn self.D","def get_dims(self):\n row_lbl, col_lbl = self.get_idxvals()\n return len(row_lbl), len(col_lbl)","def num_dim(self):\n return len(self._dimensions)","def num_dim(self):\n return len(self._dimensions)","def num_dims(self):\n return self.h5['{}/{}'.format(SETTINGS, N_DIMS_STR)][()]","def dimensionality(self):\n return int(self.nDims)","def dim(self) -> int:","def dim(self):\n return self.m, self.n","def getDimensions(self):\n return _libsbml.Layout_getDimensions(self)","def n_dims(self):\n return self.pdm.n_dims","def calculate_dimensions(self):\n x_coordinates = np.sort(self.grid['x'][:, 0]) # first x node\n self.nr_nodes_z = np.where(x_coordinates == x_coordinates[0])[0].size\n self.nr_elements_x = self.elements.shape[0] / (self.nr_nodes_z - 1)\n self.nr_nodes_x = self.nr_elements_x + 1\n self.nr_elements_z = self.nr_nodes_z - 1","def dim(self) -> int:\n pass","def dim(self):\n return self.__dim__","def dimension_size(self):\n return self._dim","def InferSpatialDimension(self):\n\n assert self.points is not None\n # if self.points.shape[1] == 3:\n # if self.element_type == \"tri\" or self.element_type == \"quad\":\n # print(\"3D surface mesh of \", self.element_type)\n\n return self.points.shape[1]","def dimensions(self):\n return len(self.parameter_names)","def dimension(self):\n return self._dim","def dimensions(self):\n return self.index.names","def dimension_count(self):\n return self._dimensionCount","def getDim(self):\n return \"%dx%d\" % (self.rows, self.cols)","def dims(self):\n raise NotImplementedError('Please use Vector2Array or Vector3Array')","def n_dims(self):\n return len(self.dimensions)","def get_dim(self, name):\n return len(self.root_group.dimensions[name])","def getDimensions(unique_name=None):","def dimension(self):\n return self.__N","def dimensions(self):\n d=dict()\n d['div'] = (self._div)\n d['var'] = len(self.used_variables)\n d['x'] = self.Xdim\n d['y'] = self.Ydim\n d['lev'] = self.lev\n d['dir'] = self._nb_dir\n return(d)","def dim(self):\n raise NotImplementedError","def num_dimensions(self):\n if self.__num_dimensions__ == 0:\n # Try to get the number of dimensions from the first point or bounding box\n if len(self.points) > 0:\n self.__num_dimensions__ = len(self.points[0].coordinate)\n elif len(self.bounding_boxes) > 0:\n self.__num_dimensions__ = len(self.bounding_boxes[0].start)\n return self.__num_dimensions__","def get_dimensions(self, variable):\n try:\n var_dimension = self.dataset[variable].dims\n return var_dimension\n except:\n print(\"Error Occurred: No Dimensions detected... Exiting. \")\n exit()","def get_dim():\n return (Settings.width, Settings.height)","def dims(x):\n return len(x.shape)","def dim(self):\n return self._dim","def count_dims(da):\n return len(da.dims)","def ndim(self):\n return self.data.ndim","def dims(self):\n return (self.startx, self.starty, self.endx, self.endy)","def getDimension(self):\n dim = len(self.__axis_labels__)\n if dim == 0:\n # Labels weren't set, so how about the data\n dim = self[0].dim()\n return dim","def size_out(self):\n return self.dimensions","def dimensions(self) -> Optional[Sequence['outputs.MetricDimensionResponse']]:\n return pulumi.get(self, \"dimensions\")","def dimensions(self) -> Optional[Sequence['outputs.MetricDimensionResponse']]:\n return pulumi.get(self, \"dimensions\")","def xdim(self):\n return len(self._x)","def getDataSetCount(self):\n\t\treturn int(self.numberOfImages / self.slicesPerTimepoint)","def GetVoxelSize(vDataSet):\r\n nx = vDataSet.GetSizeX()\r\n ny = vDataSet.GetSizeY()\r\n nz = vDataSet.GetSizeZ()\r\n\r\n if nx > 0: nx = abs(vDataSet.GetExtendMaxX()-vDataSet.GetExtendMinX())/nx;\r\n if ny > 0: ny = abs(vDataSet.GetExtendMaxY()-vDataSet.GetExtendMinY())/ny;\r\n if nz > 0: nz = abs(vDataSet.GetExtendMaxZ()-vDataSet.GetExtendMinZ())/nz;\r\n\r\n return nx,ny,nz","def get_dimensions(self, fieldname=None):\n if fieldname is None:\n dims = self._dims.keys()\n else:\n dims = self.read_field(fieldname).dimensions.keys()\n return tuple(dims)","def getDimensions(self):\n\ttop = self.getTop()\n\tleft = self.getLeft()\n\twidth = self.getWidth()\n\theight = self.getHeight()\n\treturn top, left, width, height","def size_in(self):\n return self.dimensions","def shape(self):\n return self.dataset.shape","def dim(self) -> int:\n return self._n_dim","def dim(self):\n return self.raw_wires.get_dim();","def getDimension(self):\n return len(self.components)","def get_dim(self):\n return self.dim","def dimension(self):\r\n a = 0\r\n for x in self.faces():\r\n if (len(x) > a):\r\n a = len(x) \r\n return a-1","def dimensions (self):\n return (self.width, self.height)","def dim(self) -> tuple:\n if self.has_tensor(): return self.as_tensor().dim()\n else:\n return tuple(list(self[0].dim()[0]) + [len(self)]), self[0].dim()[1]","def dataset_size(self):\n return self.dataset.size","def dim(self):\n return len(self._n)","def get_dimension_width(self):\n pass","def dim(self):\n return self._input_dim, self._output_dim","def dimension(self) -> int:\n return self.options.dimension","def dimensions(self, varname):\n if self.handle == None: return None\n try:\n var = self.handle.variables[varname]\n except KeyError:\n return None\n return var.dimensions","def dims(self):\n return tuple(d for d in (v.states for v in self.__vars)) if len(self.__vars) else (1,)","def dim(self):\n raise NotImplementedError()","def __len__(self) -> int:\n\n return self.layout.gaDims","def dim(self):\n return (self.n, )","def dimension(self):\n return self._dimension","def dimension(self):\n return self._dimension","def dimension(self):\n return self._dimension","def dimension(self):\n return self._dimension","def get_dim(self):\n return self._dim","def size(self):\n\n frame = self.get_frame()\n\n # Unpack array dimensions\n height, width, layers = np.array(frame).shape\n\n return width, height","def getdim(self):\n return round(self.w() / self.c)","def dim(self) -> int:\n return self.atoms.shape[:-1]","def ndim(self):\n return len(self.point)","def _get_dimensions(self):\n corners = []\n for module in self.modules:\n for tile in module:\n corners.append(tile.corner_idx)\n corners.append(tile.opp_corner_idx)\n corners = np.stack(corners)\n\n # Find extremes\n min_yx = corners.min(axis=0)\n max_yx = corners.max(axis=0)\n\n size = max_yx - min_yx\n centre = -min_yx\n return tuple(size), centre","def dim(self):\n return tuple(self._dim)","def _get_dimensions(self):\n corners = []\n for module in self.modules:\n for tile in module:\n corners.append(tile.corners())\n corners = np.concatenate(corners)[:, :2] / self._pixel_shape\n\n # Find extremes, add 1 px margin to allow for rounding errors\n min_xy = corners.min(axis=0).astype(int) - 1\n max_xy = corners.max(axis=0).astype(int) + 1\n\n size = max_xy - min_xy\n centre = -min_xy\n # Switch xy -> yx\n return tuple(size[::-1]), centre[::-1]"],"string":"[\n \"def getDimensions():\",\n \"def dimensions():\",\n \"def get_data_dimensions(self):\\n return image_utils.convert_shape_indexing(self._get_data_dimensions_rc(),\\\"rc\\\",self.image_indexing)\",\n \"def get_dimensions(self):\\r\\n x = []\\r\\n y = []\\r\\n z = []\\r\\n for i in self.verts:\\r\\n x.append(i[0])\\r\\n y.append(i[1])\\r\\n z.append(i[2])\\r\\n\\r\\n x.append(abs(min(x)))\\r\\n y.append(abs(min(y)))\\r\\n z.append(abs(min(z)))\\r\\n\\r\\n return max(x), max(y), max(z)\",\n \"def dims(self) -> tuple[str, str]:\\n # if self.dim0 is not None:\\n return self.y_dim, self.x_dim\",\n \"def get_num_dimensions(self):\\n dimensions = self.data.shape\\n return dimensions[1]\",\n \"def dims(self):\\n return self.v.dims() # TODO: check (empty? etc)\\n #return self.t.shape # TODO: check (empty? etc)\\n # TODO: convert to tuple? here / in varset?\",\n \"def dataDimensions(data):\\n logging.info('Number of rows of data: %s' % len(data))\\n logging.info('Number of columns of data: %s' % len(data[1]))\",\n \"def dimensions(self) -> int:\\n return pulumi.get(self, \\\"dimensions\\\")\",\n \"def dims(self):\\n return self[0].dims\",\n \"def N(self):\\n return self._dimensions\",\n \"def get_data_dim(self):\\n return self.data_dim\",\n \"def dimension(self):\\n\\t\\treturn self.d\",\n \"def get_dimensions(self):\\n return self.lon_arr.shape\",\n \"def get_data_dims(self):\\n return [len(self.tps)] + self.get_shape()[1:]\",\n \"def get_dimension_length(self):\\n pass\",\n \"def getNumDimensions(self):\\n return len(self.di.keys())\",\n \"def getDimensions(self):\\n return self._majax, self._minax, self._pa\",\n \"def size(self):\\n\\t\\treturn self.dims\",\n \"def dimension(self):\\n return 3*self.genus - 3 + self.n\",\n \"def dimension(self) -> float:\\n return self._dimensions\",\n \"def dimension(self):\",\n \"def dimensions(self) -> typing.Tuple[int, int]:\\n dimensions = self.data[2]\\n dimensions = re.findall(r'(\\\\d+)\\\\s+x\\\\s+(\\\\d+)\\\\s+M', dimensions.replace('-', '0'))\\n return dimensions[0] if dimensions else (0, 0)\",\n \"def dim(self):\\n return self._d\",\n \"def dimension(self):\\n return len(self.qubit_values)\",\n \"def dim(self):\\n\\t\\treturn self.D\",\n \"def get_dims(self):\\n row_lbl, col_lbl = self.get_idxvals()\\n return len(row_lbl), len(col_lbl)\",\n \"def num_dim(self):\\n return len(self._dimensions)\",\n \"def num_dim(self):\\n return len(self._dimensions)\",\n \"def num_dims(self):\\n return self.h5['{}/{}'.format(SETTINGS, N_DIMS_STR)][()]\",\n \"def dimensionality(self):\\n return int(self.nDims)\",\n \"def dim(self) -> int:\",\n \"def dim(self):\\n return self.m, self.n\",\n \"def getDimensions(self):\\n return _libsbml.Layout_getDimensions(self)\",\n \"def n_dims(self):\\n return self.pdm.n_dims\",\n \"def calculate_dimensions(self):\\n x_coordinates = np.sort(self.grid['x'][:, 0]) # first x node\\n self.nr_nodes_z = np.where(x_coordinates == x_coordinates[0])[0].size\\n self.nr_elements_x = self.elements.shape[0] / (self.nr_nodes_z - 1)\\n self.nr_nodes_x = self.nr_elements_x + 1\\n self.nr_elements_z = self.nr_nodes_z - 1\",\n \"def dim(self) -> int:\\n pass\",\n \"def dim(self):\\n return self.__dim__\",\n \"def dimension_size(self):\\n return self._dim\",\n \"def InferSpatialDimension(self):\\n\\n assert self.points is not None\\n # if self.points.shape[1] == 3:\\n # if self.element_type == \\\"tri\\\" or self.element_type == \\\"quad\\\":\\n # print(\\\"3D surface mesh of \\\", self.element_type)\\n\\n return self.points.shape[1]\",\n \"def dimensions(self):\\n return len(self.parameter_names)\",\n \"def dimension(self):\\n return self._dim\",\n \"def dimensions(self):\\n return self.index.names\",\n \"def dimension_count(self):\\n return self._dimensionCount\",\n \"def getDim(self):\\n return \\\"%dx%d\\\" % (self.rows, self.cols)\",\n \"def dims(self):\\n raise NotImplementedError('Please use Vector2Array or Vector3Array')\",\n \"def n_dims(self):\\n return len(self.dimensions)\",\n \"def get_dim(self, name):\\n return len(self.root_group.dimensions[name])\",\n \"def getDimensions(unique_name=None):\",\n \"def dimension(self):\\n return self.__N\",\n \"def dimensions(self):\\n d=dict()\\n d['div'] = (self._div)\\n d['var'] = len(self.used_variables)\\n d['x'] = self.Xdim\\n d['y'] = self.Ydim\\n d['lev'] = self.lev\\n d['dir'] = self._nb_dir\\n return(d)\",\n \"def dim(self):\\n raise NotImplementedError\",\n \"def num_dimensions(self):\\n if self.__num_dimensions__ == 0:\\n # Try to get the number of dimensions from the first point or bounding box\\n if len(self.points) > 0:\\n self.__num_dimensions__ = len(self.points[0].coordinate)\\n elif len(self.bounding_boxes) > 0:\\n self.__num_dimensions__ = len(self.bounding_boxes[0].start)\\n return self.__num_dimensions__\",\n \"def get_dimensions(self, variable):\\n try:\\n var_dimension = self.dataset[variable].dims\\n return var_dimension\\n except:\\n print(\\\"Error Occurred: No Dimensions detected... Exiting. \\\")\\n exit()\",\n \"def get_dim():\\n return (Settings.width, Settings.height)\",\n \"def dims(x):\\n return len(x.shape)\",\n \"def dim(self):\\n return self._dim\",\n \"def count_dims(da):\\n return len(da.dims)\",\n \"def ndim(self):\\n return self.data.ndim\",\n \"def dims(self):\\n return (self.startx, self.starty, self.endx, self.endy)\",\n \"def getDimension(self):\\n dim = len(self.__axis_labels__)\\n if dim == 0:\\n # Labels weren't set, so how about the data\\n dim = self[0].dim()\\n return dim\",\n \"def size_out(self):\\n return self.dimensions\",\n \"def dimensions(self) -> Optional[Sequence['outputs.MetricDimensionResponse']]:\\n return pulumi.get(self, \\\"dimensions\\\")\",\n \"def dimensions(self) -> Optional[Sequence['outputs.MetricDimensionResponse']]:\\n return pulumi.get(self, \\\"dimensions\\\")\",\n \"def xdim(self):\\n return len(self._x)\",\n \"def getDataSetCount(self):\\n\\t\\treturn int(self.numberOfImages / self.slicesPerTimepoint)\",\n \"def GetVoxelSize(vDataSet):\\r\\n nx = vDataSet.GetSizeX()\\r\\n ny = vDataSet.GetSizeY()\\r\\n nz = vDataSet.GetSizeZ()\\r\\n\\r\\n if nx > 0: nx = abs(vDataSet.GetExtendMaxX()-vDataSet.GetExtendMinX())/nx;\\r\\n if ny > 0: ny = abs(vDataSet.GetExtendMaxY()-vDataSet.GetExtendMinY())/ny;\\r\\n if nz > 0: nz = abs(vDataSet.GetExtendMaxZ()-vDataSet.GetExtendMinZ())/nz;\\r\\n\\r\\n return nx,ny,nz\",\n \"def get_dimensions(self, fieldname=None):\\n if fieldname is None:\\n dims = self._dims.keys()\\n else:\\n dims = self.read_field(fieldname).dimensions.keys()\\n return tuple(dims)\",\n \"def getDimensions(self):\\n\\ttop = self.getTop()\\n\\tleft = self.getLeft()\\n\\twidth = self.getWidth()\\n\\theight = self.getHeight()\\n\\treturn top, left, width, height\",\n \"def size_in(self):\\n return self.dimensions\",\n \"def shape(self):\\n return self.dataset.shape\",\n \"def dim(self) -> int:\\n return self._n_dim\",\n \"def dim(self):\\n return self.raw_wires.get_dim();\",\n \"def getDimension(self):\\n return len(self.components)\",\n \"def get_dim(self):\\n return self.dim\",\n \"def dimension(self):\\r\\n a = 0\\r\\n for x in self.faces():\\r\\n if (len(x) > a):\\r\\n a = len(x) \\r\\n return a-1\",\n \"def dimensions (self):\\n return (self.width, self.height)\",\n \"def dim(self) -> tuple:\\n if self.has_tensor(): return self.as_tensor().dim()\\n else:\\n return tuple(list(self[0].dim()[0]) + [len(self)]), self[0].dim()[1]\",\n \"def dataset_size(self):\\n return self.dataset.size\",\n \"def dim(self):\\n return len(self._n)\",\n \"def get_dimension_width(self):\\n pass\",\n \"def dim(self):\\n return self._input_dim, self._output_dim\",\n \"def dimension(self) -> int:\\n return self.options.dimension\",\n \"def dimensions(self, varname):\\n if self.handle == None: return None\\n try:\\n var = self.handle.variables[varname]\\n except KeyError:\\n return None\\n return var.dimensions\",\n \"def dims(self):\\n return tuple(d for d in (v.states for v in self.__vars)) if len(self.__vars) else (1,)\",\n \"def dim(self):\\n raise NotImplementedError()\",\n \"def __len__(self) -> int:\\n\\n return self.layout.gaDims\",\n \"def dim(self):\\n return (self.n, )\",\n \"def dimension(self):\\n return self._dimension\",\n \"def dimension(self):\\n return self._dimension\",\n \"def dimension(self):\\n return self._dimension\",\n \"def dimension(self):\\n return self._dimension\",\n \"def get_dim(self):\\n return self._dim\",\n \"def size(self):\\n\\n frame = self.get_frame()\\n\\n # Unpack array dimensions\\n height, width, layers = np.array(frame).shape\\n\\n return width, height\",\n \"def getdim(self):\\n return round(self.w() / self.c)\",\n \"def dim(self) -> int:\\n return self.atoms.shape[:-1]\",\n \"def ndim(self):\\n return len(self.point)\",\n \"def _get_dimensions(self):\\n corners = []\\n for module in self.modules:\\n for tile in module:\\n corners.append(tile.corner_idx)\\n corners.append(tile.opp_corner_idx)\\n corners = np.stack(corners)\\n\\n # Find extremes\\n min_yx = corners.min(axis=0)\\n max_yx = corners.max(axis=0)\\n\\n size = max_yx - min_yx\\n centre = -min_yx\\n return tuple(size), centre\",\n \"def dim(self):\\n return tuple(self._dim)\",\n \"def _get_dimensions(self):\\n corners = []\\n for module in self.modules:\\n for tile in module:\\n corners.append(tile.corners())\\n corners = np.concatenate(corners)[:, :2] / self._pixel_shape\\n\\n # Find extremes, add 1 px margin to allow for rounding errors\\n min_xy = corners.min(axis=0).astype(int) - 1\\n max_xy = corners.max(axis=0).astype(int) + 1\\n\\n size = max_xy - min_xy\\n centre = -min_xy\\n # Switch xy -> yx\\n return tuple(size[::-1]), centre[::-1]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7814758","0.77764654","0.77693594","0.76322365","0.74653226","0.7423212","0.7418739","0.7339198","0.7303002","0.7278066","0.7271514","0.72714305","0.7247757","0.7213372","0.7206813","0.71931577","0.7168946","0.7104327","0.71030354","0.7093483","0.70858115","0.7071672","0.706293","0.7042327","0.70330995","0.70280665","0.7014977","0.69848776","0.69848776","0.69213","0.6914094","0.6889391","0.68878496","0.68841964","0.68749046","0.6866607","0.68660533","0.6860869","0.6852686","0.6850619","0.6847674","0.6846514","0.68429494","0.6840511","0.68235224","0.68228894","0.68190074","0.6816659","0.6797553","0.6794924","0.67931783","0.6778195","0.677182","0.67630386","0.6761141","0.6755946","0.67492616","0.67402416","0.67344815","0.67336506","0.6728515","0.67277163","0.67258596","0.67258596","0.67115635","0.670725","0.6705827","0.6676417","0.66747504","0.66738045","0.66714835","0.6662445","0.6661982","0.6659658","0.66446996","0.6642593","0.6634986","0.6630627","0.6613186","0.6606938","0.660239","0.660072","0.65932727","0.6584298","0.65812355","0.658086","0.6576606","0.65712863","0.65592617","0.65592617","0.65592617","0.65592617","0.6550893","0.65403926","0.65383965","0.6533388","0.6531744","0.6529495","0.6523486","0.6520885"],"string":"[\n \"0.7814758\",\n \"0.77764654\",\n \"0.77693594\",\n \"0.76322365\",\n \"0.74653226\",\n \"0.7423212\",\n \"0.7418739\",\n \"0.7339198\",\n \"0.7303002\",\n \"0.7278066\",\n \"0.7271514\",\n \"0.72714305\",\n \"0.7247757\",\n \"0.7213372\",\n \"0.7206813\",\n \"0.71931577\",\n \"0.7168946\",\n \"0.7104327\",\n \"0.71030354\",\n \"0.7093483\",\n \"0.70858115\",\n \"0.7071672\",\n \"0.706293\",\n \"0.7042327\",\n \"0.70330995\",\n \"0.70280665\",\n \"0.7014977\",\n \"0.69848776\",\n \"0.69848776\",\n \"0.69213\",\n \"0.6914094\",\n \"0.6889391\",\n \"0.68878496\",\n \"0.68841964\",\n \"0.68749046\",\n \"0.6866607\",\n \"0.68660533\",\n \"0.6860869\",\n \"0.6852686\",\n \"0.6850619\",\n \"0.6847674\",\n \"0.6846514\",\n \"0.68429494\",\n \"0.6840511\",\n \"0.68235224\",\n \"0.68228894\",\n \"0.68190074\",\n \"0.6816659\",\n \"0.6797553\",\n \"0.6794924\",\n \"0.67931783\",\n \"0.6778195\",\n \"0.677182\",\n \"0.67630386\",\n \"0.6761141\",\n \"0.6755946\",\n \"0.67492616\",\n \"0.67402416\",\n \"0.67344815\",\n \"0.67336506\",\n \"0.6728515\",\n \"0.67277163\",\n \"0.67258596\",\n \"0.67258596\",\n \"0.67115635\",\n \"0.670725\",\n \"0.6705827\",\n \"0.6676417\",\n \"0.66747504\",\n \"0.66738045\",\n \"0.66714835\",\n \"0.6662445\",\n \"0.6661982\",\n \"0.6659658\",\n \"0.66446996\",\n \"0.6642593\",\n \"0.6634986\",\n \"0.6630627\",\n \"0.6613186\",\n \"0.6606938\",\n \"0.660239\",\n \"0.660072\",\n \"0.65932727\",\n \"0.6584298\",\n \"0.65812355\",\n \"0.658086\",\n \"0.6576606\",\n \"0.65712863\",\n \"0.65592617\",\n \"0.65592617\",\n \"0.65592617\",\n \"0.65592617\",\n \"0.6550893\",\n \"0.65403926\",\n \"0.65383965\",\n \"0.6533388\",\n \"0.6531744\",\n \"0.6529495\",\n \"0.6523486\",\n \"0.6520885\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7157837"},"document_rank":{"kind":"string","value":"17"}}},{"rowIdx":94993,"cells":{"query":{"kind":"string","value":"Returns the spacing of the datasets this dataunit contains"},"document":{"kind":"string","value":"def getSpacing(self):\n\t\tif not self.spacing:\n\t\t\ta, b, c = self.getVoxelSize()\n\t\t\tself.spacing = [1, b / a, c / a]\n\t\treturn self.spacing"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def GetSpacing(self):\r\n\r\n return self._spacing","def spacings(self):\n return np.array([self.pixel_spacing,\n self.pixel_spacing,\n self.slice_spacing])","def spacing(self):\r\n\r\n return self.dx, self.dy, self.dz","def margin(self):\r\n return self._generate_spacing_info(self.config['margin'])","def get_spaces(self):\n return self.spaces","def _calculate_spacing(self):\n # Spacing between each raindrop is 1 drop width/height.\n drop = Raindrop(self)\n drop_width, drop_height = drop.rect.size\n avail_space_x = self.rain_settings.screen_width - drop_width\n number_raindrops_x = avail_space_x // (2 * drop_width)\n\n # Determine the number of rows of raindrops that fit on the screen.\n avail_space_y = self.rain_settings.screen_height\n number_raindrops_y = avail_space_y // (2 * drop_height)\n\n return (\n avail_space_x, avail_space_y,\n number_raindrops_x, number_raindrops_y,\n drop_width, drop_height\n )","def horizontal_spacing(self):\r\n return self.padding[1] + self.padding[3] + self.margin[1] + self.margin[3]","def slice_spacing(self):\n return np.median(np.diff(self.slice_zvals))","def get_um_spacing(self) -> Spacing:\n return tuple(float(x * 10**6) for x in self.spacing)","def GetSpacerPixels(self):\r\n\r\n return self.spacer_pixels","def padding(self):\r\n return self._generate_spacing_info(self.config['padding'])","def expected_data_spacing(self, expected_data_spacing):\n\n self._expected_data_spacing = expected_data_spacing","def GetToolSeparation(self):\r\n \r\n if self._art:\r\n return self._art.GetElementSize(AUI_TBART_SEPARATOR_SIZE)\r\n\r\n return 5","def vertical_spacing(self):\r\n return self.padding[0] + self.padding[2] + self.margin[0] + self.margin[2]","def margins(self) -> tuple[int, int, int, int]:\n return self._widget._mgui_get_margins()","def gap_width(self):\n return self.container['gap_width']","def get_distance_scale(self, row_spacing: float) -> tuple:\r\n \r\n return (self.field.get_row_spacing(), row_spacing)","def getDim(self):\n return \"%dx%d\" % (self.rows, self.cols)","def get_row_spacing(self) -> tuple:\r\n\r\n # Get the y coordinate of the line through each of the\r\n # field's rows at the middle of the image\r\n ys = [line[0] * (self.get_picture().get_size()[0] / 2) + line[1]\r\n for line in self.lines]\r\n\r\n # Get the distances between each of the approximated rows and sort them\r\n dists = sorted([ys[i] - ys[i - 1] for i in range(1, len(ys))])\r\n\r\n # Take the median of the distances\r\n dist_px = dists[len(dists)//2]\r\n\r\n return dist_px","def getDimensions():","def getSpace(self):\n return self.space","def get_spacing(network):\n from openpnm.topotools.generators.tools import get_spacing\n d = {'vert.coords': network.coords, 'edge.conns': network.conns}\n spc = get_spacing(d)\n return spc","def padding(self):\n pad = self.ntiles - self.windowsize\n return (int((pad - 1)/2.), int((pad + 1)/2.))","def GetNiceExtentsBySpacing(minval,maxval,spacing,tolerance):\n pass","def dimension(self):","def __len__(self) -> int:\n\n return self.layout.gaDims","def _find_spacing(self, row, ordering, max_width):\n return max_width / (len(ordering[row]) + 1)","def spacing(self, spacing):\n\n self._spacing = spacing","def get_dim():\n return (Settings.width, Settings.height)","def dimensions():","def widths(self):\n return self._widths","def getDimensions(self):\n\t\tprint \"Returning\",self.x,self.y,self.slicesPerTimepoint\n\t\treturn (self.x, self.y, self.slicesPerTimepoint)","def gutter_spacing(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"gutter_spacing\")","def gutter_spacing(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"gutter_spacing\")","def gutter_spacing(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"gutter_spacing\")","def GetSpacing(self, p_int, p_float=..., p_float=..., p_float=...):\n ...","def getIndividualWidths(self):\n nquad = self.getNumQuads()\n widths = np.zeros(nquad)\n for i in range(nquad):\n q = self._quadrilaterals[i]\n widths[i] = get_quad_width(q) / 1000.0\n return widths","def get_dimension_width(self):\n pass","def dim(self) -> int:\n pass","def get_space(self):\n return self.space","def margin_size(self) -> int:\n return self._margin_size","def dims(self) -> tuple[str, str]:\n # if self.dim0 is not None:\n return self.y_dim, self.x_dim","def DimStyle0(self):\n\t\treturn self.Space(0)","def get_data_dim(self):\n return self.data_dim","def space(self):\n return self._space","def dimension(self):\n\t\treturn self.d","def get_margin(self):\n return unicode(self._visual_indent * 20)","def margin_width(self):\n return self.border_width() + self.margin_left + self.margin_right","def contentsMargins( self ):\n return self._margins","def dimension(self):\n return 3*self.genus - 3 + self.n","def get_dimension_length(self):\n pass","def getDimensions(self):\n return _libsbml.Layout_getDimensions(self)","def getMargin(self):\n assert False","def dim(self) -> int:","def width(self) -> int:","def width(self) -> int:","def getSpace(*args):","def get_widths(self) -> tuple:\n words_width = 0\n spaces_width = 0\n for part in self.line_parts:\n words_width += part.width\n spaces_width += part.spaces_width\n return words_width, spaces_width","def dim(self):\n\t\treturn self.D","def ideal_spacing(data, npoints):\n dims = data.shape\n actual_npoints = (data >= 0).sum()\n spacing = np.ones(3, dtype='uint')\n\n while actual_npoints > npoints:\n\n # Subsample the direction with the highest number of samples\n ddims = dims / spacing\n if ddims[0] >= ddims[1] and ddims[0] >= ddims[2]:\n dir = 0\n elif ddims[1] > ddims[0] and ddims[1] >= ddims[2]:\n dir = 1\n else:\n dir = 2\n spacing[dir] += 1\n subdata = data[::spacing[0], ::spacing[1], ::spacing[2]]\n actual_npoints = (subdata >= 0).sum()\n\n return spacing","def padding_width(self):\n\t\treturn self.paddings_shape_param('W')","def testViewGapData(self):\n try:\n entryD = self.__mU.doImport(self.__instanceSavePath, fmt=\"pickle\")\n gapCountList = []\n gapLengthList = []\n entryCountD = {}\n for entryId in entryD:\n for _, eD in entryD[entryId][\"selected_polymer_entities\"].items():\n\n analD = eD[\"anal_instances\"] if \"anal_instances\" in eD else {}\n\n for _, aD in analD.items():\n entryCountD[entryId] = True\n gapCount = len(aD[\"gapD\"])\n tL = list(aD[\"gapD\"].values())\n tL = [t if t > 0 else 0 for t in tL]\n gapL = tL if tL else [0]\n gapCountList.append(gapCount)\n gapLengthList.extend(gapL)\n #\n logger.info(\"gaps %d gap lengths %d\", len(gapCountList), len(gapLengthList))\n #\n cu = DisorderChartUtils()\n # cu.doIntegerBarChart(gapCountList, plotPath=self.__plotGapCount, yPlotScale=None, yPlotMax=300000)\n cu.doIntegerBarChart(\n gapCountList,\n plotPath=self.__plotGapCount,\n yPlotScale=\"log\",\n yPlotMax=6,\n xPlotMax=30,\n xPlotLabel=\"Gap Count\",\n yPlotLabel=\"Protein Instances (log)\",\n plotTitle=\"Protein Instance Gap Count\",\n )\n self.__writeLegend(\n self.__plotGapCount,\n \"Gap count statistics for all (%d) protein sequences (%d X-ray structures with resolution limit < 3.5 Angstoms) \" % (len(gapCountList), len(entryCountD)),\n )\n cu.doIntegerBarChart(\n gapLengthList,\n plotPath=self.__plotGapLength,\n yPlotScale=\"log\",\n yPlotMax=6,\n xPlotMax=150,\n xPlotLabel=\"Gap width (residues)\",\n yPlotLabel=\"Gap Instances (log)\",\n plotTitle=\"Protein Instance Gap Widths\",\n )\n self.__writeLegend(\n self.__plotGapLength,\n \"Gap width statistics for all (%d) protein sequences (%d X-ray structures with resolution limit < 3.5 Angstoms) \" % (len(gapLengthList), len(entryCountD)),\n )\n except Exception as e:\n logger.exception(\"Failing with %s\", str(e))\n self.fail()","def thickness(self):\n return self._thickness","def kspace(self):\n return self.kspace_x, self.kspace_y, self.kspace_data","def dim_calculatorP3():\r\n probe_set = np.arange(1, 101)\r\n X = 20 - 36 + ((probe_set - 1) // 10) * 4\r\n Y = 2 - ((probe_set - 1) % 10) * 4\r\n dim = np.vstack((X, Y)).T\r\n return dim","def observation_space_size(self) -> int:\n pass","def dimensions(self) -> int:\n return pulumi.get(self, \"dimensions\")","def margin(self) -> Tuple[int, int, int, int]:\n return (self.imargin[0].to_pixels(self.parent.width),\n self.imargin[1].to_pixels(self.parent.width),\n self.imargin[2].to_pixels(self.parent.height),\n self.imargin[3].to_pixels(self.parent.height))","def getdim(self):\n return round(self.w() / self.c)","def _update_dimensions(self):\n _, self.width = self.window.getmaxyx()\n self.spacing = self.width // self.total_columns","def custom_spacing(width, height):\n\t\treturn c.lift(imgui.dummy, width, height)","def dim(self):\n raise NotImplementedError","def dataDimensions(data):\n logging.info('Number of rows of data: %s' % len(data))\n logging.info('Number of columns of data: %s' % len(data[1]))","def pixel_spacing_range(self) -> Optional[float]:\n return self._get_property(PIXEL_SPACING_RANGE_PROP, float)","def width(self):\n\t\tpass","def dim(self):\n return self.__dim__","def numspans(self):\n return self.mesh.size - 1","def dim(self):\n return self._d","def set_margins_and_spacing(self):\n\n #margin_list\n margin_list = [0,0,0,0]\n\n #lyt_classes_list\n lyt_classes_list = [QtGui.QStackedLayout, QtGui.QGridLayout, QtGui.QFormLayout, \n QtGui.QBoxLayout, QtGui.QVBoxLayout, QtGui.QHBoxLayout, QtGui.QBoxLayout]\n\n #lyt_list\n lyt_list = []\n for lyt_class in lyt_classes_list:\n lyt_list += [wdgt for wdgt in self.findChildren(lyt_class)]\n\n\n \n #set margin and spacing\n for lyt in lyt_list:\n\n #check type\n if(type(lyt) in lyt_classes_list):\n\n #set\n lyt.setContentsMargins(*margin_list)\n lyt.setSpacing(0)","def widths(self):\n return self._ax.widths","def width(self):\n return self._get_mean_and_samples_attribute('width')","def spacingEnergy(self, controlpoints):\n # only remember each spacing energy if the given control points are\n # the snakes current control points\n memorize_energies = np.equal(controlpoints, self.controlpoints).all()\n # reset the spacing energy list if necessary\n if memorize_energies:\n self.spc_energies = []\n \n spacing = 0.0\n # iterate over the adjacent control points\n for i in range(len(controlpoints)):\n if i < len(controlpoints)-1:\n ci = controlpoints[i]\n ci_next = controlpoints[i+1]\n \n # compute the distance between the two points\n di = (ci_next[0]-ci[0], ci_next[1]-ci[1])\n di_abs = sqrt(di[0]**2 + di[1]**2)\n current_spacing = ((di_abs/self.goal_length)-1)**2\n \n # add to the overall value\n spacing += current_spacing\n # safe to list if necessary\n if memorize_energies:\n self.spc_energies.append(current_spacing)\n return spacing","def dim_calculator():\r\n probe_set = np.arange(1, 101)\r\n X = -36 + ((probe_set - 1) // 10) * 4\r\n Y = 2 - ((probe_set - 1) % 10) * 4\r\n dim = np.vstack((X, Y)).T\r\n return dim","def dim(self):\n return (self.n, )","def compute_kspace_units(self):\n if self.c1.has_analytic_ft:\n support_x, support_y = self.c2.support_x, self.c2.support_y\n sample_spacing = self.c2.sample_spacing\n elif self.c2.has_analytic_ft:\n support_x, support_y = self.c1.support_x, self.c1.support_y\n sample_spacing = self.c1.sample_spacing\n else:\n support_x = max(self.c1.support_x, self.c2.support_x)\n support_y = max(self.c1.support_y, self.c2.support_y)\n sample_spacing = min(self.c1.sample_spacing, self.c2.sample_spacing)\n\n self.sample_spacing = sample_spacing\n self.nsamples_x = int(e.floor(round(((support_x / sample_spacing) + 1) * self.Q, 6)))\n self.nsamples_y = int(e.floor(round(((support_y / sample_spacing) + 1) * self.Q, 6)))\n self.kspace_x = forward_ft_unit(sample_spacing, self.nsamples_x, True)\n self.kspace_y = forward_ft_unit(sample_spacing, self.nsamples_y, True)\n return self","def Space(self):\n\t\tif self.acad.ActiveDocument.ActiveLayout.ModelType:\n\t\t\treturn self.acad.ActiveDocument.ModelSpace\n\t\telse:\n\t\t\treturn self.acad.ActiveDocument.PaperSpace","def dimension(self) -> float:\n return self._dimensions","def getDimensions(self):\n return self._majax, self._minax, self._pa","def default_dimensions(self):\r\n try:\r\n dimension1, dimension2 = self.dimension_finder(self.text_header)\r\n except:\r\n dimension1, dimension2 = 0,0\r\n return (dimension1, dimension2)","def GetIndentSize(self):\r\n\r\n return 5","def indicator_space() -> List[Dimension]:\n return [\n Integer(15, 40, name='bull-buy-rsi-value'),\n Integer(10, 30, name='bear-buy-rsi-value'),\n ]","def N(self):\n return self._dimensions","def dim(self):\n raise NotImplementedError()","def padding(self):\n\t\treturn self.paddings_shape_param('W')","def get_grid_spacing(self, grid_id, grid_spacing):\n grid_spacing = self._grid_spacing[grid_id]","def test_get_xy_space():\n pass","def getDataSetCount(self):\n\t\treturn int(self.numberOfImages / self.slicesPerTimepoint)","def get_spacing(filename='POSCAR', cut=0.9):\n\n structure = Structure.from_file('POSCAR')\n\n lines = open(filename).readlines()\n c_axis = lines[4].split()\n lattice_parameter = lines[1].split()\n split_coords = [line.split() for line in lines[8:8+structure.num_sites]]\n z_coords = list()\n for coord in split_coords:\n z_coord = float(coord[2])\n if z_coord > cut:\n z_coord -= 1\n z_coords.append(z_coord)\n max_height = max([z_height for z_height in z_coords])\n min_height = min([z_height for z_height in z_coords])\n spacing = ((1.0 + min_height) - max_height) * \\\n abs(float(c_axis[2])) * float(lattice_parameter[0])\n\n return spacing","def dim(self):\n return self._dim","def calc_cspace(self, mapdata, padding):\n rospy.loginfo(\"Calculating C-Space\")\n c_Space = OccupancyGrid()\n c_Space.header = mapdata.header\n c_Space.info = mapdata.info\n\n c_Space_data = list(mapdata.data)\n listOfPoints = []\n for x in range(mapdata.info.width):\n for y in range(mapdata.info.height):\n index = self.grid_to_index(mapdata,x,y)\n for j in range (padding +1) :\n for k in range(padding +1):\n if(mapdata.data[index] == 100):\n c_Space_data[index] = 100\n if ((x+j) > mapdata.info.width -1 or (x+j) < 0 or (y+k)> mapdata.info.height -1 or (y+k) <0):\n pass\n else:\n index1 = self.grid_to_index(mapdata, (x+j), (y+k))\n c_Space_data[index1] = 100\n listOfPoints.append((x+j, y+k))\n\n if ((x-j) > mapdata.info.width -1 or (x-j) < 0 or (y+k)> mapdata.info.height -1 or (y+k) <0):\n pass\n else:\n index2 = self.grid_to_index(mapdata, (x-j), (y+k))\n c_Space_data[index2] = 100\n listOfPoints.append((x-j, y+k)) \n\n if ((x+j) > mapdata.info.width -1 or (x+j) < 0 or (y-k)> mapdata.info.height -1 or (y-k) <0):\n pass\n else:\n index3 = self.grid_to_index(mapdata, (x+j), (y-k))\n c_Space_data[index3] = 100\n listOfPoints.append((x+j, y-k))\n\n if ((x-j) > mapdata.info.width -1 or (x-j) < 0 or (y-k)> mapdata.info.height -1 or (y-k) <0):\n pass\n else:\n index4 = self.grid_to_index(mapdata, (x-j), (y-k))\n c_Space_data[index4] = 100\n listOfPoints.append((x-j, y-k))\n c_Space.data=c_Space_data\n self.cspace_pub.publish(c_Space)\n rospy.loginfo(\"Publishing OccupancyGrid for C-Space\")\n return c_Space"],"string":"[\n \"def GetSpacing(self):\\r\\n\\r\\n return self._spacing\",\n \"def spacings(self):\\n return np.array([self.pixel_spacing,\\n self.pixel_spacing,\\n self.slice_spacing])\",\n \"def spacing(self):\\r\\n\\r\\n return self.dx, self.dy, self.dz\",\n \"def margin(self):\\r\\n return self._generate_spacing_info(self.config['margin'])\",\n \"def get_spaces(self):\\n return self.spaces\",\n \"def _calculate_spacing(self):\\n # Spacing between each raindrop is 1 drop width/height.\\n drop = Raindrop(self)\\n drop_width, drop_height = drop.rect.size\\n avail_space_x = self.rain_settings.screen_width - drop_width\\n number_raindrops_x = avail_space_x // (2 * drop_width)\\n\\n # Determine the number of rows of raindrops that fit on the screen.\\n avail_space_y = self.rain_settings.screen_height\\n number_raindrops_y = avail_space_y // (2 * drop_height)\\n\\n return (\\n avail_space_x, avail_space_y,\\n number_raindrops_x, number_raindrops_y,\\n drop_width, drop_height\\n )\",\n \"def horizontal_spacing(self):\\r\\n return self.padding[1] + self.padding[3] + self.margin[1] + self.margin[3]\",\n \"def slice_spacing(self):\\n return np.median(np.diff(self.slice_zvals))\",\n \"def get_um_spacing(self) -> Spacing:\\n return tuple(float(x * 10**6) for x in self.spacing)\",\n \"def GetSpacerPixels(self):\\r\\n\\r\\n return self.spacer_pixels\",\n \"def padding(self):\\r\\n return self._generate_spacing_info(self.config['padding'])\",\n \"def expected_data_spacing(self, expected_data_spacing):\\n\\n self._expected_data_spacing = expected_data_spacing\",\n \"def GetToolSeparation(self):\\r\\n \\r\\n if self._art:\\r\\n return self._art.GetElementSize(AUI_TBART_SEPARATOR_SIZE)\\r\\n\\r\\n return 5\",\n \"def vertical_spacing(self):\\r\\n return self.padding[0] + self.padding[2] + self.margin[0] + self.margin[2]\",\n \"def margins(self) -> tuple[int, int, int, int]:\\n return self._widget._mgui_get_margins()\",\n \"def gap_width(self):\\n return self.container['gap_width']\",\n \"def get_distance_scale(self, row_spacing: float) -> tuple:\\r\\n \\r\\n return (self.field.get_row_spacing(), row_spacing)\",\n \"def getDim(self):\\n return \\\"%dx%d\\\" % (self.rows, self.cols)\",\n \"def get_row_spacing(self) -> tuple:\\r\\n\\r\\n # Get the y coordinate of the line through each of the\\r\\n # field's rows at the middle of the image\\r\\n ys = [line[0] * (self.get_picture().get_size()[0] / 2) + line[1]\\r\\n for line in self.lines]\\r\\n\\r\\n # Get the distances between each of the approximated rows and sort them\\r\\n dists = sorted([ys[i] - ys[i - 1] for i in range(1, len(ys))])\\r\\n\\r\\n # Take the median of the distances\\r\\n dist_px = dists[len(dists)//2]\\r\\n\\r\\n return dist_px\",\n \"def getDimensions():\",\n \"def getSpace(self):\\n return self.space\",\n \"def get_spacing(network):\\n from openpnm.topotools.generators.tools import get_spacing\\n d = {'vert.coords': network.coords, 'edge.conns': network.conns}\\n spc = get_spacing(d)\\n return spc\",\n \"def padding(self):\\n pad = self.ntiles - self.windowsize\\n return (int((pad - 1)/2.), int((pad + 1)/2.))\",\n \"def GetNiceExtentsBySpacing(minval,maxval,spacing,tolerance):\\n pass\",\n \"def dimension(self):\",\n \"def __len__(self) -> int:\\n\\n return self.layout.gaDims\",\n \"def _find_spacing(self, row, ordering, max_width):\\n return max_width / (len(ordering[row]) + 1)\",\n \"def spacing(self, spacing):\\n\\n self._spacing = spacing\",\n \"def get_dim():\\n return (Settings.width, Settings.height)\",\n \"def dimensions():\",\n \"def widths(self):\\n return self._widths\",\n \"def getDimensions(self):\\n\\t\\tprint \\\"Returning\\\",self.x,self.y,self.slicesPerTimepoint\\n\\t\\treturn (self.x, self.y, self.slicesPerTimepoint)\",\n \"def gutter_spacing(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"gutter_spacing\\\")\",\n \"def gutter_spacing(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"gutter_spacing\\\")\",\n \"def gutter_spacing(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"gutter_spacing\\\")\",\n \"def GetSpacing(self, p_int, p_float=..., p_float=..., p_float=...):\\n ...\",\n \"def getIndividualWidths(self):\\n nquad = self.getNumQuads()\\n widths = np.zeros(nquad)\\n for i in range(nquad):\\n q = self._quadrilaterals[i]\\n widths[i] = get_quad_width(q) / 1000.0\\n return widths\",\n \"def get_dimension_width(self):\\n pass\",\n \"def dim(self) -> int:\\n pass\",\n \"def get_space(self):\\n return self.space\",\n \"def margin_size(self) -> int:\\n return self._margin_size\",\n \"def dims(self) -> tuple[str, str]:\\n # if self.dim0 is not None:\\n return self.y_dim, self.x_dim\",\n \"def DimStyle0(self):\\n\\t\\treturn self.Space(0)\",\n \"def get_data_dim(self):\\n return self.data_dim\",\n \"def space(self):\\n return self._space\",\n \"def dimension(self):\\n\\t\\treturn self.d\",\n \"def get_margin(self):\\n return unicode(self._visual_indent * 20)\",\n \"def margin_width(self):\\n return self.border_width() + self.margin_left + self.margin_right\",\n \"def contentsMargins( self ):\\n return self._margins\",\n \"def dimension(self):\\n return 3*self.genus - 3 + self.n\",\n \"def get_dimension_length(self):\\n pass\",\n \"def getDimensions(self):\\n return _libsbml.Layout_getDimensions(self)\",\n \"def getMargin(self):\\n assert False\",\n \"def dim(self) -> int:\",\n \"def width(self) -> int:\",\n \"def width(self) -> int:\",\n \"def getSpace(*args):\",\n \"def get_widths(self) -> tuple:\\n words_width = 0\\n spaces_width = 0\\n for part in self.line_parts:\\n words_width += part.width\\n spaces_width += part.spaces_width\\n return words_width, spaces_width\",\n \"def dim(self):\\n\\t\\treturn self.D\",\n \"def ideal_spacing(data, npoints):\\n dims = data.shape\\n actual_npoints = (data >= 0).sum()\\n spacing = np.ones(3, dtype='uint')\\n\\n while actual_npoints > npoints:\\n\\n # Subsample the direction with the highest number of samples\\n ddims = dims / spacing\\n if ddims[0] >= ddims[1] and ddims[0] >= ddims[2]:\\n dir = 0\\n elif ddims[1] > ddims[0] and ddims[1] >= ddims[2]:\\n dir = 1\\n else:\\n dir = 2\\n spacing[dir] += 1\\n subdata = data[::spacing[0], ::spacing[1], ::spacing[2]]\\n actual_npoints = (subdata >= 0).sum()\\n\\n return spacing\",\n \"def padding_width(self):\\n\\t\\treturn self.paddings_shape_param('W')\",\n \"def testViewGapData(self):\\n try:\\n entryD = self.__mU.doImport(self.__instanceSavePath, fmt=\\\"pickle\\\")\\n gapCountList = []\\n gapLengthList = []\\n entryCountD = {}\\n for entryId in entryD:\\n for _, eD in entryD[entryId][\\\"selected_polymer_entities\\\"].items():\\n\\n analD = eD[\\\"anal_instances\\\"] if \\\"anal_instances\\\" in eD else {}\\n\\n for _, aD in analD.items():\\n entryCountD[entryId] = True\\n gapCount = len(aD[\\\"gapD\\\"])\\n tL = list(aD[\\\"gapD\\\"].values())\\n tL = [t if t > 0 else 0 for t in tL]\\n gapL = tL if tL else [0]\\n gapCountList.append(gapCount)\\n gapLengthList.extend(gapL)\\n #\\n logger.info(\\\"gaps %d gap lengths %d\\\", len(gapCountList), len(gapLengthList))\\n #\\n cu = DisorderChartUtils()\\n # cu.doIntegerBarChart(gapCountList, plotPath=self.__plotGapCount, yPlotScale=None, yPlotMax=300000)\\n cu.doIntegerBarChart(\\n gapCountList,\\n plotPath=self.__plotGapCount,\\n yPlotScale=\\\"log\\\",\\n yPlotMax=6,\\n xPlotMax=30,\\n xPlotLabel=\\\"Gap Count\\\",\\n yPlotLabel=\\\"Protein Instances (log)\\\",\\n plotTitle=\\\"Protein Instance Gap Count\\\",\\n )\\n self.__writeLegend(\\n self.__plotGapCount,\\n \\\"Gap count statistics for all (%d) protein sequences (%d X-ray structures with resolution limit < 3.5 Angstoms) \\\" % (len(gapCountList), len(entryCountD)),\\n )\\n cu.doIntegerBarChart(\\n gapLengthList,\\n plotPath=self.__plotGapLength,\\n yPlotScale=\\\"log\\\",\\n yPlotMax=6,\\n xPlotMax=150,\\n xPlotLabel=\\\"Gap width (residues)\\\",\\n yPlotLabel=\\\"Gap Instances (log)\\\",\\n plotTitle=\\\"Protein Instance Gap Widths\\\",\\n )\\n self.__writeLegend(\\n self.__plotGapLength,\\n \\\"Gap width statistics for all (%d) protein sequences (%d X-ray structures with resolution limit < 3.5 Angstoms) \\\" % (len(gapLengthList), len(entryCountD)),\\n )\\n except Exception as e:\\n logger.exception(\\\"Failing with %s\\\", str(e))\\n self.fail()\",\n \"def thickness(self):\\n return self._thickness\",\n \"def kspace(self):\\n return self.kspace_x, self.kspace_y, self.kspace_data\",\n \"def dim_calculatorP3():\\r\\n probe_set = np.arange(1, 101)\\r\\n X = 20 - 36 + ((probe_set - 1) // 10) * 4\\r\\n Y = 2 - ((probe_set - 1) % 10) * 4\\r\\n dim = np.vstack((X, Y)).T\\r\\n return dim\",\n \"def observation_space_size(self) -> int:\\n pass\",\n \"def dimensions(self) -> int:\\n return pulumi.get(self, \\\"dimensions\\\")\",\n \"def margin(self) -> Tuple[int, int, int, int]:\\n return (self.imargin[0].to_pixels(self.parent.width),\\n self.imargin[1].to_pixels(self.parent.width),\\n self.imargin[2].to_pixels(self.parent.height),\\n self.imargin[3].to_pixels(self.parent.height))\",\n \"def getdim(self):\\n return round(self.w() / self.c)\",\n \"def _update_dimensions(self):\\n _, self.width = self.window.getmaxyx()\\n self.spacing = self.width // self.total_columns\",\n \"def custom_spacing(width, height):\\n\\t\\treturn c.lift(imgui.dummy, width, height)\",\n \"def dim(self):\\n raise NotImplementedError\",\n \"def dataDimensions(data):\\n logging.info('Number of rows of data: %s' % len(data))\\n logging.info('Number of columns of data: %s' % len(data[1]))\",\n \"def pixel_spacing_range(self) -> Optional[float]:\\n return self._get_property(PIXEL_SPACING_RANGE_PROP, float)\",\n \"def width(self):\\n\\t\\tpass\",\n \"def dim(self):\\n return self.__dim__\",\n \"def numspans(self):\\n return self.mesh.size - 1\",\n \"def dim(self):\\n return self._d\",\n \"def set_margins_and_spacing(self):\\n\\n #margin_list\\n margin_list = [0,0,0,0]\\n\\n #lyt_classes_list\\n lyt_classes_list = [QtGui.QStackedLayout, QtGui.QGridLayout, QtGui.QFormLayout, \\n QtGui.QBoxLayout, QtGui.QVBoxLayout, QtGui.QHBoxLayout, QtGui.QBoxLayout]\\n\\n #lyt_list\\n lyt_list = []\\n for lyt_class in lyt_classes_list:\\n lyt_list += [wdgt for wdgt in self.findChildren(lyt_class)]\\n\\n\\n \\n #set margin and spacing\\n for lyt in lyt_list:\\n\\n #check type\\n if(type(lyt) in lyt_classes_list):\\n\\n #set\\n lyt.setContentsMargins(*margin_list)\\n lyt.setSpacing(0)\",\n \"def widths(self):\\n return self._ax.widths\",\n \"def width(self):\\n return self._get_mean_and_samples_attribute('width')\",\n \"def spacingEnergy(self, controlpoints):\\n # only remember each spacing energy if the given control points are\\n # the snakes current control points\\n memorize_energies = np.equal(controlpoints, self.controlpoints).all()\\n # reset the spacing energy list if necessary\\n if memorize_energies:\\n self.spc_energies = []\\n \\n spacing = 0.0\\n # iterate over the adjacent control points\\n for i in range(len(controlpoints)):\\n if i < len(controlpoints)-1:\\n ci = controlpoints[i]\\n ci_next = controlpoints[i+1]\\n \\n # compute the distance between the two points\\n di = (ci_next[0]-ci[0], ci_next[1]-ci[1])\\n di_abs = sqrt(di[0]**2 + di[1]**2)\\n current_spacing = ((di_abs/self.goal_length)-1)**2\\n \\n # add to the overall value\\n spacing += current_spacing\\n # safe to list if necessary\\n if memorize_energies:\\n self.spc_energies.append(current_spacing)\\n return spacing\",\n \"def dim_calculator():\\r\\n probe_set = np.arange(1, 101)\\r\\n X = -36 + ((probe_set - 1) // 10) * 4\\r\\n Y = 2 - ((probe_set - 1) % 10) * 4\\r\\n dim = np.vstack((X, Y)).T\\r\\n return dim\",\n \"def dim(self):\\n return (self.n, )\",\n \"def compute_kspace_units(self):\\n if self.c1.has_analytic_ft:\\n support_x, support_y = self.c2.support_x, self.c2.support_y\\n sample_spacing = self.c2.sample_spacing\\n elif self.c2.has_analytic_ft:\\n support_x, support_y = self.c1.support_x, self.c1.support_y\\n sample_spacing = self.c1.sample_spacing\\n else:\\n support_x = max(self.c1.support_x, self.c2.support_x)\\n support_y = max(self.c1.support_y, self.c2.support_y)\\n sample_spacing = min(self.c1.sample_spacing, self.c2.sample_spacing)\\n\\n self.sample_spacing = sample_spacing\\n self.nsamples_x = int(e.floor(round(((support_x / sample_spacing) + 1) * self.Q, 6)))\\n self.nsamples_y = int(e.floor(round(((support_y / sample_spacing) + 1) * self.Q, 6)))\\n self.kspace_x = forward_ft_unit(sample_spacing, self.nsamples_x, True)\\n self.kspace_y = forward_ft_unit(sample_spacing, self.nsamples_y, True)\\n return self\",\n \"def Space(self):\\n\\t\\tif self.acad.ActiveDocument.ActiveLayout.ModelType:\\n\\t\\t\\treturn self.acad.ActiveDocument.ModelSpace\\n\\t\\telse:\\n\\t\\t\\treturn self.acad.ActiveDocument.PaperSpace\",\n \"def dimension(self) -> float:\\n return self._dimensions\",\n \"def getDimensions(self):\\n return self._majax, self._minax, self._pa\",\n \"def default_dimensions(self):\\r\\n try:\\r\\n dimension1, dimension2 = self.dimension_finder(self.text_header)\\r\\n except:\\r\\n dimension1, dimension2 = 0,0\\r\\n return (dimension1, dimension2)\",\n \"def GetIndentSize(self):\\r\\n\\r\\n return 5\",\n \"def indicator_space() -> List[Dimension]:\\n return [\\n Integer(15, 40, name='bull-buy-rsi-value'),\\n Integer(10, 30, name='bear-buy-rsi-value'),\\n ]\",\n \"def N(self):\\n return self._dimensions\",\n \"def dim(self):\\n raise NotImplementedError()\",\n \"def padding(self):\\n\\t\\treturn self.paddings_shape_param('W')\",\n \"def get_grid_spacing(self, grid_id, grid_spacing):\\n grid_spacing = self._grid_spacing[grid_id]\",\n \"def test_get_xy_space():\\n pass\",\n \"def getDataSetCount(self):\\n\\t\\treturn int(self.numberOfImages / self.slicesPerTimepoint)\",\n \"def get_spacing(filename='POSCAR', cut=0.9):\\n\\n structure = Structure.from_file('POSCAR')\\n\\n lines = open(filename).readlines()\\n c_axis = lines[4].split()\\n lattice_parameter = lines[1].split()\\n split_coords = [line.split() for line in lines[8:8+structure.num_sites]]\\n z_coords = list()\\n for coord in split_coords:\\n z_coord = float(coord[2])\\n if z_coord > cut:\\n z_coord -= 1\\n z_coords.append(z_coord)\\n max_height = max([z_height for z_height in z_coords])\\n min_height = min([z_height for z_height in z_coords])\\n spacing = ((1.0 + min_height) - max_height) * \\\\\\n abs(float(c_axis[2])) * float(lattice_parameter[0])\\n\\n return spacing\",\n \"def dim(self):\\n return self._dim\",\n \"def calc_cspace(self, mapdata, padding):\\n rospy.loginfo(\\\"Calculating C-Space\\\")\\n c_Space = OccupancyGrid()\\n c_Space.header = mapdata.header\\n c_Space.info = mapdata.info\\n\\n c_Space_data = list(mapdata.data)\\n listOfPoints = []\\n for x in range(mapdata.info.width):\\n for y in range(mapdata.info.height):\\n index = self.grid_to_index(mapdata,x,y)\\n for j in range (padding +1) :\\n for k in range(padding +1):\\n if(mapdata.data[index] == 100):\\n c_Space_data[index] = 100\\n if ((x+j) > mapdata.info.width -1 or (x+j) < 0 or (y+k)> mapdata.info.height -1 or (y+k) <0):\\n pass\\n else:\\n index1 = self.grid_to_index(mapdata, (x+j), (y+k))\\n c_Space_data[index1] = 100\\n listOfPoints.append((x+j, y+k))\\n\\n if ((x-j) > mapdata.info.width -1 or (x-j) < 0 or (y+k)> mapdata.info.height -1 or (y+k) <0):\\n pass\\n else:\\n index2 = self.grid_to_index(mapdata, (x-j), (y+k))\\n c_Space_data[index2] = 100\\n listOfPoints.append((x-j, y+k)) \\n\\n if ((x+j) > mapdata.info.width -1 or (x+j) < 0 or (y-k)> mapdata.info.height -1 or (y-k) <0):\\n pass\\n else:\\n index3 = self.grid_to_index(mapdata, (x+j), (y-k))\\n c_Space_data[index3] = 100\\n listOfPoints.append((x+j, y-k))\\n\\n if ((x-j) > mapdata.info.width -1 or (x-j) < 0 or (y-k)> mapdata.info.height -1 or (y-k) <0):\\n pass\\n else:\\n index4 = self.grid_to_index(mapdata, (x-j), (y-k))\\n c_Space_data[index4] = 100\\n listOfPoints.append((x-j, y-k))\\n c_Space.data=c_Space_data\\n self.cspace_pub.publish(c_Space)\\n rospy.loginfo(\\\"Publishing OccupancyGrid for C-Space\\\")\\n return c_Space\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69162726","0.6651873","0.66186863","0.6618427","0.6541836","0.64272296","0.6390034","0.6284166","0.6187805","0.61713886","0.6085297","0.6026972","0.6021646","0.60199386","0.5960843","0.5940496","0.59104943","0.5868685","0.573976","0.5731771","0.57220376","0.56487423","0.56223077","0.5594772","0.55903035","0.55810946","0.5577763","0.5576113","0.55648994","0.555305","0.55424625","0.5523321","0.55190796","0.55190796","0.55190796","0.5503417","0.5485612","0.5468764","0.5434494","0.54340833","0.54312396","0.54252404","0.54201066","0.54178953","0.5413793","0.5413681","0.53998077","0.53892297","0.5359313","0.53581214","0.5351968","0.53451","0.53429466","0.53414935","0.534078","0.534078","0.53249055","0.52890927","0.52869886","0.5284249","0.52797264","0.5276143","0.52652884","0.5257448","0.5255773","0.52418303","0.5236235","0.5234077","0.5233128","0.5228916","0.52285725","0.522376","0.5223402","0.52211905","0.52166706","0.5213663","0.52015954","0.52011657","0.51847965","0.51844543","0.51823604","0.5182218","0.5179822","0.5173287","0.5162146","0.515002","0.514977","0.5139248","0.51362693","0.51348644","0.51337516","0.51335496","0.5130295","0.5130214","0.5129097","0.51240355","0.5118522","0.51140684","0.51066035","0.5090071"],"string":"[\n \"0.69162726\",\n \"0.6651873\",\n \"0.66186863\",\n \"0.6618427\",\n \"0.6541836\",\n \"0.64272296\",\n \"0.6390034\",\n \"0.6284166\",\n \"0.6187805\",\n \"0.61713886\",\n \"0.6085297\",\n \"0.6026972\",\n \"0.6021646\",\n \"0.60199386\",\n \"0.5960843\",\n \"0.5940496\",\n \"0.59104943\",\n \"0.5868685\",\n \"0.573976\",\n \"0.5731771\",\n \"0.57220376\",\n \"0.56487423\",\n \"0.56223077\",\n \"0.5594772\",\n \"0.55903035\",\n \"0.55810946\",\n \"0.5577763\",\n \"0.5576113\",\n \"0.55648994\",\n \"0.555305\",\n \"0.55424625\",\n \"0.5523321\",\n \"0.55190796\",\n \"0.55190796\",\n \"0.55190796\",\n \"0.5503417\",\n \"0.5485612\",\n \"0.5468764\",\n \"0.5434494\",\n \"0.54340833\",\n \"0.54312396\",\n \"0.54252404\",\n \"0.54201066\",\n \"0.54178953\",\n \"0.5413793\",\n \"0.5413681\",\n \"0.53998077\",\n \"0.53892297\",\n \"0.5359313\",\n \"0.53581214\",\n \"0.5351968\",\n \"0.53451\",\n \"0.53429466\",\n \"0.53414935\",\n \"0.534078\",\n \"0.534078\",\n \"0.53249055\",\n \"0.52890927\",\n \"0.52869886\",\n \"0.5284249\",\n \"0.52797264\",\n \"0.5276143\",\n \"0.52652884\",\n \"0.5257448\",\n \"0.5255773\",\n \"0.52418303\",\n \"0.5236235\",\n \"0.5234077\",\n \"0.5233128\",\n \"0.5228916\",\n \"0.52285725\",\n \"0.522376\",\n \"0.5223402\",\n \"0.52211905\",\n \"0.52166706\",\n \"0.5213663\",\n \"0.52015954\",\n \"0.52011657\",\n \"0.51847965\",\n \"0.51844543\",\n \"0.51823604\",\n \"0.5182218\",\n \"0.5179822\",\n \"0.5173287\",\n \"0.5162146\",\n \"0.515002\",\n \"0.514977\",\n \"0.5139248\",\n \"0.51362693\",\n \"0.51348644\",\n \"0.51337516\",\n \"0.51335496\",\n \"0.5130295\",\n \"0.5130214\",\n \"0.5129097\",\n \"0.51240355\",\n \"0.5118522\",\n \"0.51140684\",\n \"0.51066035\",\n \"0.5090071\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7266339"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94994,"cells":{"query":{"kind":"string","value":"Returns the voxel size of the datasets this dataunit contains"},"document":{"kind":"string","value":"def getVoxelSize(self):\n\t\treturn self.voxelsize"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def voxel_size(self):\n return self.calculation.voxel_size","def dataset_size(self):\n return self.dataset.size","def GetVoxelSize(vDataSet):\r\n nx = vDataSet.GetSizeX()\r\n ny = vDataSet.GetSizeY()\r\n nz = vDataSet.GetSizeZ()\r\n\r\n if nx > 0: nx = abs(vDataSet.GetExtendMaxX()-vDataSet.GetExtendMinX())/nx;\r\n if ny > 0: ny = abs(vDataSet.GetExtendMaxY()-vDataSet.GetExtendMinY())/ny;\r\n if nz > 0: nz = abs(vDataSet.GetExtendMaxZ()-vDataSet.GetExtendMinZ())/nz;\r\n\r\n return nx,ny,nz","def voxel_count(self):\n return self.cols * self.rows * self.sections","def voxel_size(self):\n # Set experiment if unset:\n if self._exp is None:\n self._populate_exp()\n\n # Set cframe if unset:\n if self._coord_frame is None:\n self._populate_coord_frame()\n\n if self.axis_order == AxisOrder.XYZ:\n vox_size = (\n self._coord_frame.x_voxel_size,\n self._coord_frame.y_voxel_size,\n self._coord_frame.z_voxel_size,\n )\n elif self.axis_order == AxisOrder.ZYX:\n vox_size = (\n self._coord_frame.z_voxel_size,\n self._coord_frame.y_voxel_size,\n self._coord_frame.x_voxel_size,\n )\n return (vox_size, self._coord_frame.voxel_unit)","def getDataSetCount(self):\n\t\treturn int(self.numberOfImages / self.slicesPerTimepoint)","def size(self, index):\n return self.base_dataset.size(index)","def __len__(self):\n return self._dataset.size(dirs=self._dirs)","def get_num_dimensions(self):\n dimensions = self.data.shape\n return dimensions[1]","def dimension(self):\n return len(self.qubit_values)","def dimension_size(self):\n return self._dim","def get_size(self):\n # return the size along the index dimension\n size = 0\n if self._data is not None:\n size = shape(self._data)[self.index_dimension]\n\n return size","def get_data_dim(self):\n return self.data_dim","def size(self):\n ret = 0\n for ii in self.__data:\n ret += int(ii.get_size())\n return ret","def get_voxel_size(self, axis):\n assert axis in MRI3Daxes\n if self.meta_data is not None:\n affine, header = self.meta_data\n return header['pixdim'][1:4][MRI3Daxes.index(axis)]\n else:\n raise Exception('xndarray does not have any meta data to get'\n 'voxel size')","def dataset_size(self):\n if not self._dataset_size:\n # pylint: disable=attribute-defined-outside-init\n self._dataset_size = count_file_lines(\n self._hparams.source_dataset.files)\n return self._dataset_size","def width(self) -> int:\n return self._obj[self.x_dim].size","def size(self):\n\t\treturn self.dims","def get_size(self):\n tmpsize = 0\n for variable in self.variables:\n tmpsize += variable.get_size()\n for subchunk in self.subchunks:\n tmpsize += subchunk.get_size()\n return tmpsize","def get_total_item_size(dataset):\n total_items = 0\n for element in dataset:\n total_items += 1\n return total_items","def get_data_dimensions(self):\n return image_utils.convert_shape_indexing(self._get_data_dimensions_rc(),\"rc\",self.image_indexing)","def num_dim(self):\n return len(self._dimensions)","def num_dim(self):\n return len(self._dimensions)","def data_size(self) -> int:\n return len(self.__labels)","def size(self):\n size = 1\n for current_slice in self.slices:\n size *= current_slice.stop - current_slice.start\n return size","def _get_dataset_size(loader):\n if isinstance(loader, (tuple, list)):\n return len(loader[0].dataset)\n else:\n return len(loader.dataset)","def number_of_data_nodes(self):\n return int(self._data['number_of_data_nodes'])","def get_dimension_length(self):\n pass","def getDimension(self):\n return len(self.components)","def dimension(self):\r\n a = 0\r\n for x in self.faces():\r\n if (len(x) > a):\r\n a = len(x) \r\n return a-1","def count(self):\r\n return self.data_array.size","def get_size(self):\n return (\n sys.getsizeof(self.children) +\n sys.getsizeof(self.parent) +\n sys.getsizeof(self.dataset_id) +\n sys.getsizeof(self.k) +\n self.filter.get_size()\n )","def size_in(self):\n return self.dimensions","def get_dim(self, name):\n return len(self.root_group.dimensions[name])","def getNumDimensions(self):\n return len(self.di.keys())","def size(self) -> int:\n\n return self.sizes.sum()","def dim(self) -> int:\n return self._n_dim","def get_voxel_size(path: str) -> float:\n dcm = pydicom.dcmread(path, force=True)\n x_str, y_str = dcm.PixelSpacing\n x = Decimal(str(x_str))\n y = Decimal(str(y_str))\n z = Decimal(str(dcm.SpacingBetweenSlices))\n print(float(x * y * z))\n return float(x * y * z)","def dimension_count(self):\n return self._dimensionCount","def get_num_points(self):\n dimensions = self.data.shape\n return dimensions[0]","def __len__(self):\r\n if self.is_superset:\r\n length = 0\r\n for ds in self.data:\r\n length += len(ds)\r\n return length\r\n else:\r\n return len(self.data)","def size(self):\n size = 0\n size += self.data.size * sys.getsizeof(self.data)\n return size / 1024.0 / 1024.0 / 1024.0","def element_size(self):\n vecs = (\n self.nodes[self.elements[:, :4], :][:, 1:, :]\n - self.nodes[self.elements[:, :4], :][:, 0, None, :]\n )\n return np.abs(np.linalg.det(vecs)) / 6","def xdim(self):\n return len(self._x)","def get_size(self):\n return self._data_size","def __len__(self) -> int:\n import h5py\n\n with h5py.File(\n os.path.join(self.root, self.data_dir, self.img_file_name), \"r\"\n ) as f:\n num_datapoints: int = f[self.split][\"pv_log\"].shape[0]\n\n return num_datapoints","def size(self) -> int:\n size = self.da.length()\n return size","def size(self)->int:\n\n return np.prod([axes if is_integer(axes) else len(axes) for axes in self._dim_axes])","def size(self):\n return self.data.size","def size(self):\r\n return len(self._train_datas)","def get_nbytes(dset):\n if 'nbytes' in dset.attrs:\n # look if the dataset has an attribute nbytes\n return dset.attrs['nbytes']\n elif hasattr(dset, 'value'):\n # else extract nbytes from the underlying array\n return dset.size * numpy.zeros(1, dset.dtype).nbytes","def dimension(self) -> float:\n return self._dimensions","def size(self):\n futures = self.client.map(_call_size, self.vecDask, pure=False)\n sizes = self.client.gather(futures)\n return np.sum(sizes)","def get_value_size(self):\n size = 0\n if self._data is not None:\n size = shape(self._data)[self.value_dimension]\n\n return size","def size(self):\n return self.__row_count * self.__col_count","def n_points(self):\n\n if self.data_reduced:\n return len(self.data_reduced[0])\n else:\n return 0","def __len__(self):\n if not self.opt.union:\n return min(len(self.dataset), self.opt.max_dataset_size)\n else:\n return len(self.batch_sampler)","def num_dimensions(self):\n if self.__num_dimensions__ == 0:\n # Try to get the number of dimensions from the first point or bounding box\n if len(self.points) > 0:\n self.__num_dimensions__ = len(self.points[0].coordinate)\n elif len(self.bounding_boxes) > 0:\n self.__num_dimensions__ = len(self.bounding_boxes[0].start)\n return self.__num_dimensions__","def dim(self):\n return len(self._n)","def size(self) -> pulumi.Output[float]:\n return pulumi.get(self, \"size\")","def ndarray_size(self) -> int:\n pass","def GetDataSetSize(ds_type, name_len, num_elements, element_multipler):\n\n # Number of bytes in the data type\n datatype_size = 4\n if ds_type == 50: # Byte Datatype\n datatype_size = 1\n elif ds_type == 20: # Int Datatype\n datatype_size = 4\n elif ds_type == 10: # Float Datatype\n datatype_size = 4\n\n return ((num_elements * element_multipler) * datatype_size) + Ensemble.GetBaseDataSize(name_len)","def getDimension(self):\n dim = len(self.__axis_labels__)\n if dim == 0:\n # Labels weren't set, so how about the data\n dim = self[0].dim()\n return dim","def XSize(self):\n return self.dataset.RasterXSize if self.dataset else None","def dataDimensions(data):\n logging.info('Number of rows of data: %s' % len(data))\n logging.info('Number of columns of data: %s' % len(data[1]))","def get_size(self):\n tmpsize = 0\n for variable in self.variables:\n tmpsize += variable.get_size()\n for subchunk in self.subchunks:\n tmpsize += subchunk.get_size()\n self.size.value = tmpsize\n return self.size.value + self.ID.get_size() + self.size.get_size()","def size(self):\n return int(misc.intprod(self.shape))","def __len__(self):\n return int(np.floor(len(self.dataset_df) / self.batch_size))","def nbytes(self) -> int:\n\n return self.data.nbytes + self.shape.nbytes","def dimension(self):\n return 3*self.genus - 3 + self.n","def dimension(self):\n return self.__N","def size(self):\n return self.N","def ndim(self):\n return self.data.ndim","def __len__(self):\n return self.dataset.shape[0]","def get_data_size(self):\n if self.doc_ftrs is not None:\n data = self.doc_ftrs\n elif self.query_ftrs:\n data = self.query_ftrs\n elif self.usr_ftrs:\n data = self.usr_ftrs\n else:\n raise ValueError('Cannot infer data size.')\n data_shape = tf.shape(data)\n return data_shape[0], data_shape[1]","def size_out(self):\n return self.dimensions","def __len__(self):\n\t\treturn min(len(self.dataset), self.opt.max_dataset_size)","def nbytes(self):\n\n return self.data.type.datasize","def size(self) -> Tuple[groupable, pdarray]:\n return self.count()","def dim(self) -> int:\n pass","def countDataSize(self,filename):\n \n d = h5py.File(filename,'r')\n features = d['spectrometer/features'][:]\n select = self.selectData(features.astype(float), self.ifeature, d)\n N = len(features[select])\n d.close()\n\n N = (N//self.offsetLen) * self.offsetLen\n\n N = N*self.Nfeeds\n\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\n self.datasizes += [int(N/self.Nfeeds)]\n self.Nsamples += int(N)","def __get_dataset_size(input_):\n in_type = __get_input_type(input_)\n b_unit = 1024.0 * 1024.0\n if in_type == \"numpy_array\":\n size_in_MB = input_.nbytes / b_unit\n elif in_type == \"hdf\":\n size_in_MB = os.path.getsize(input_) / b_unit\n else:\n list_file = losa.find_file(input_ + \"/*.tif*\")\n if list_file:\n size_1_file = np.asarray(Image.open(list_file[0])).nbytes / b_unit\n else:\n size_1_file = 0.0\n size_in_MB = len(list_file) * size_1_file\n return size_in_MB","def nbytes(self):\n dtype = self.config[\"dtype\"]\n if dtype is None:\n return None\n\n size = reduce(mul, self.shape, 1)\n nbytes = size * dtype.itemsize\n\n if getattr(self, \"masked\", True):\n nbytes += size\n\n return nbytes","def get_size(self, hdf):\n return sum([sys.getsizeof(hdf[p]) for p in hdf.list_nodes()]) + sum(\n [self.get_size(hdf[p]) for p in hdf.list_groups()]\n )","def data_size( self, groups ):\n #if len(groups) == 0:\n # return 0\n return max( groups.values() )","def nbytes(self):\n # type: () -> int\n size = 0\n for chunk in self.data.chunks:\n for buf in chunk.buffers():\n size += buf.size\n return size","def dimensions():","def num_elements(self):\n return self.subset.num_elements()","def get_size(self):\n return self._surf.get_size()","def count_data(self):\n try:\n ndata = len(self.x)\n logger.info(\"Number of data points: {0}\".format(ndata))\n except AttributeError:\n logger.error(\"Data object has not been defined\")\n ndata = 0\n return ndata","def get_length(self):\n if self.opt.num_buckets > 1:\n return sum([len(bucket) for bucket in self.data])\n else:\n return len(self.data)","def __len__( self ):\n return len( self._raster_data )","def graph_data_size(self) -> int:\n return int(self.graph_tuple_stats.graph_data_size or 0)","def test_size(self) -> int:\n return int(self.data_size * self.__test_fraction)","def size(self) -> int:\n return self.da.length()","def size(self) -> int:\n return self.da.length()","def size(self) -> int:\n return self.da.length()","def size(self) -> int:\n return self.da.length()","def n_dims(self):\n return len(self.dimensions)","def size(self, batch):\n x,y,m = batch \n return sum([mm.sum() for mm in m])"],"string":"[\n \"def voxel_size(self):\\n return self.calculation.voxel_size\",\n \"def dataset_size(self):\\n return self.dataset.size\",\n \"def GetVoxelSize(vDataSet):\\r\\n nx = vDataSet.GetSizeX()\\r\\n ny = vDataSet.GetSizeY()\\r\\n nz = vDataSet.GetSizeZ()\\r\\n\\r\\n if nx > 0: nx = abs(vDataSet.GetExtendMaxX()-vDataSet.GetExtendMinX())/nx;\\r\\n if ny > 0: ny = abs(vDataSet.GetExtendMaxY()-vDataSet.GetExtendMinY())/ny;\\r\\n if nz > 0: nz = abs(vDataSet.GetExtendMaxZ()-vDataSet.GetExtendMinZ())/nz;\\r\\n\\r\\n return nx,ny,nz\",\n \"def voxel_count(self):\\n return self.cols * self.rows * self.sections\",\n \"def voxel_size(self):\\n # Set experiment if unset:\\n if self._exp is None:\\n self._populate_exp()\\n\\n # Set cframe if unset:\\n if self._coord_frame is None:\\n self._populate_coord_frame()\\n\\n if self.axis_order == AxisOrder.XYZ:\\n vox_size = (\\n self._coord_frame.x_voxel_size,\\n self._coord_frame.y_voxel_size,\\n self._coord_frame.z_voxel_size,\\n )\\n elif self.axis_order == AxisOrder.ZYX:\\n vox_size = (\\n self._coord_frame.z_voxel_size,\\n self._coord_frame.y_voxel_size,\\n self._coord_frame.x_voxel_size,\\n )\\n return (vox_size, self._coord_frame.voxel_unit)\",\n \"def getDataSetCount(self):\\n\\t\\treturn int(self.numberOfImages / self.slicesPerTimepoint)\",\n \"def size(self, index):\\n return self.base_dataset.size(index)\",\n \"def __len__(self):\\n return self._dataset.size(dirs=self._dirs)\",\n \"def get_num_dimensions(self):\\n dimensions = self.data.shape\\n return dimensions[1]\",\n \"def dimension(self):\\n return len(self.qubit_values)\",\n \"def dimension_size(self):\\n return self._dim\",\n \"def get_size(self):\\n # return the size along the index dimension\\n size = 0\\n if self._data is not None:\\n size = shape(self._data)[self.index_dimension]\\n\\n return size\",\n \"def get_data_dim(self):\\n return self.data_dim\",\n \"def size(self):\\n ret = 0\\n for ii in self.__data:\\n ret += int(ii.get_size())\\n return ret\",\n \"def get_voxel_size(self, axis):\\n assert axis in MRI3Daxes\\n if self.meta_data is not None:\\n affine, header = self.meta_data\\n return header['pixdim'][1:4][MRI3Daxes.index(axis)]\\n else:\\n raise Exception('xndarray does not have any meta data to get'\\n 'voxel size')\",\n \"def dataset_size(self):\\n if not self._dataset_size:\\n # pylint: disable=attribute-defined-outside-init\\n self._dataset_size = count_file_lines(\\n self._hparams.source_dataset.files)\\n return self._dataset_size\",\n \"def width(self) -> int:\\n return self._obj[self.x_dim].size\",\n \"def size(self):\\n\\t\\treturn self.dims\",\n \"def get_size(self):\\n tmpsize = 0\\n for variable in self.variables:\\n tmpsize += variable.get_size()\\n for subchunk in self.subchunks:\\n tmpsize += subchunk.get_size()\\n return tmpsize\",\n \"def get_total_item_size(dataset):\\n total_items = 0\\n for element in dataset:\\n total_items += 1\\n return total_items\",\n \"def get_data_dimensions(self):\\n return image_utils.convert_shape_indexing(self._get_data_dimensions_rc(),\\\"rc\\\",self.image_indexing)\",\n \"def num_dim(self):\\n return len(self._dimensions)\",\n \"def num_dim(self):\\n return len(self._dimensions)\",\n \"def data_size(self) -> int:\\n return len(self.__labels)\",\n \"def size(self):\\n size = 1\\n for current_slice in self.slices:\\n size *= current_slice.stop - current_slice.start\\n return size\",\n \"def _get_dataset_size(loader):\\n if isinstance(loader, (tuple, list)):\\n return len(loader[0].dataset)\\n else:\\n return len(loader.dataset)\",\n \"def number_of_data_nodes(self):\\n return int(self._data['number_of_data_nodes'])\",\n \"def get_dimension_length(self):\\n pass\",\n \"def getDimension(self):\\n return len(self.components)\",\n \"def dimension(self):\\r\\n a = 0\\r\\n for x in self.faces():\\r\\n if (len(x) > a):\\r\\n a = len(x) \\r\\n return a-1\",\n \"def count(self):\\r\\n return self.data_array.size\",\n \"def get_size(self):\\n return (\\n sys.getsizeof(self.children) +\\n sys.getsizeof(self.parent) +\\n sys.getsizeof(self.dataset_id) +\\n sys.getsizeof(self.k) +\\n self.filter.get_size()\\n )\",\n \"def size_in(self):\\n return self.dimensions\",\n \"def get_dim(self, name):\\n return len(self.root_group.dimensions[name])\",\n \"def getNumDimensions(self):\\n return len(self.di.keys())\",\n \"def size(self) -> int:\\n\\n return self.sizes.sum()\",\n \"def dim(self) -> int:\\n return self._n_dim\",\n \"def get_voxel_size(path: str) -> float:\\n dcm = pydicom.dcmread(path, force=True)\\n x_str, y_str = dcm.PixelSpacing\\n x = Decimal(str(x_str))\\n y = Decimal(str(y_str))\\n z = Decimal(str(dcm.SpacingBetweenSlices))\\n print(float(x * y * z))\\n return float(x * y * z)\",\n \"def dimension_count(self):\\n return self._dimensionCount\",\n \"def get_num_points(self):\\n dimensions = self.data.shape\\n return dimensions[0]\",\n \"def __len__(self):\\r\\n if self.is_superset:\\r\\n length = 0\\r\\n for ds in self.data:\\r\\n length += len(ds)\\r\\n return length\\r\\n else:\\r\\n return len(self.data)\",\n \"def size(self):\\n size = 0\\n size += self.data.size * sys.getsizeof(self.data)\\n return size / 1024.0 / 1024.0 / 1024.0\",\n \"def element_size(self):\\n vecs = (\\n self.nodes[self.elements[:, :4], :][:, 1:, :]\\n - self.nodes[self.elements[:, :4], :][:, 0, None, :]\\n )\\n return np.abs(np.linalg.det(vecs)) / 6\",\n \"def xdim(self):\\n return len(self._x)\",\n \"def get_size(self):\\n return self._data_size\",\n \"def __len__(self) -> int:\\n import h5py\\n\\n with h5py.File(\\n os.path.join(self.root, self.data_dir, self.img_file_name), \\\"r\\\"\\n ) as f:\\n num_datapoints: int = f[self.split][\\\"pv_log\\\"].shape[0]\\n\\n return num_datapoints\",\n \"def size(self) -> int:\\n size = self.da.length()\\n return size\",\n \"def size(self)->int:\\n\\n return np.prod([axes if is_integer(axes) else len(axes) for axes in self._dim_axes])\",\n \"def size(self):\\n return self.data.size\",\n \"def size(self):\\r\\n return len(self._train_datas)\",\n \"def get_nbytes(dset):\\n if 'nbytes' in dset.attrs:\\n # look if the dataset has an attribute nbytes\\n return dset.attrs['nbytes']\\n elif hasattr(dset, 'value'):\\n # else extract nbytes from the underlying array\\n return dset.size * numpy.zeros(1, dset.dtype).nbytes\",\n \"def dimension(self) -> float:\\n return self._dimensions\",\n \"def size(self):\\n futures = self.client.map(_call_size, self.vecDask, pure=False)\\n sizes = self.client.gather(futures)\\n return np.sum(sizes)\",\n \"def get_value_size(self):\\n size = 0\\n if self._data is not None:\\n size = shape(self._data)[self.value_dimension]\\n\\n return size\",\n \"def size(self):\\n return self.__row_count * self.__col_count\",\n \"def n_points(self):\\n\\n if self.data_reduced:\\n return len(self.data_reduced[0])\\n else:\\n return 0\",\n \"def __len__(self):\\n if not self.opt.union:\\n return min(len(self.dataset), self.opt.max_dataset_size)\\n else:\\n return len(self.batch_sampler)\",\n \"def num_dimensions(self):\\n if self.__num_dimensions__ == 0:\\n # Try to get the number of dimensions from the first point or bounding box\\n if len(self.points) > 0:\\n self.__num_dimensions__ = len(self.points[0].coordinate)\\n elif len(self.bounding_boxes) > 0:\\n self.__num_dimensions__ = len(self.bounding_boxes[0].start)\\n return self.__num_dimensions__\",\n \"def dim(self):\\n return len(self._n)\",\n \"def size(self) -> pulumi.Output[float]:\\n return pulumi.get(self, \\\"size\\\")\",\n \"def ndarray_size(self) -> int:\\n pass\",\n \"def GetDataSetSize(ds_type, name_len, num_elements, element_multipler):\\n\\n # Number of bytes in the data type\\n datatype_size = 4\\n if ds_type == 50: # Byte Datatype\\n datatype_size = 1\\n elif ds_type == 20: # Int Datatype\\n datatype_size = 4\\n elif ds_type == 10: # Float Datatype\\n datatype_size = 4\\n\\n return ((num_elements * element_multipler) * datatype_size) + Ensemble.GetBaseDataSize(name_len)\",\n \"def getDimension(self):\\n dim = len(self.__axis_labels__)\\n if dim == 0:\\n # Labels weren't set, so how about the data\\n dim = self[0].dim()\\n return dim\",\n \"def XSize(self):\\n return self.dataset.RasterXSize if self.dataset else None\",\n \"def dataDimensions(data):\\n logging.info('Number of rows of data: %s' % len(data))\\n logging.info('Number of columns of data: %s' % len(data[1]))\",\n \"def get_size(self):\\n tmpsize = 0\\n for variable in self.variables:\\n tmpsize += variable.get_size()\\n for subchunk in self.subchunks:\\n tmpsize += subchunk.get_size()\\n self.size.value = tmpsize\\n return self.size.value + self.ID.get_size() + self.size.get_size()\",\n \"def size(self):\\n return int(misc.intprod(self.shape))\",\n \"def __len__(self):\\n return int(np.floor(len(self.dataset_df) / self.batch_size))\",\n \"def nbytes(self) -> int:\\n\\n return self.data.nbytes + self.shape.nbytes\",\n \"def dimension(self):\\n return 3*self.genus - 3 + self.n\",\n \"def dimension(self):\\n return self.__N\",\n \"def size(self):\\n return self.N\",\n \"def ndim(self):\\n return self.data.ndim\",\n \"def __len__(self):\\n return self.dataset.shape[0]\",\n \"def get_data_size(self):\\n if self.doc_ftrs is not None:\\n data = self.doc_ftrs\\n elif self.query_ftrs:\\n data = self.query_ftrs\\n elif self.usr_ftrs:\\n data = self.usr_ftrs\\n else:\\n raise ValueError('Cannot infer data size.')\\n data_shape = tf.shape(data)\\n return data_shape[0], data_shape[1]\",\n \"def size_out(self):\\n return self.dimensions\",\n \"def __len__(self):\\n\\t\\treturn min(len(self.dataset), self.opt.max_dataset_size)\",\n \"def nbytes(self):\\n\\n return self.data.type.datasize\",\n \"def size(self) -> Tuple[groupable, pdarray]:\\n return self.count()\",\n \"def dim(self) -> int:\\n pass\",\n \"def countDataSize(self,filename):\\n \\n d = h5py.File(filename,'r')\\n features = d['spectrometer/features'][:]\\n select = self.selectData(features.astype(float), self.ifeature, d)\\n N = len(features[select])\\n d.close()\\n\\n N = (N//self.offsetLen) * self.offsetLen\\n\\n N = N*self.Nfeeds\\n\\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\\n self.datasizes += [int(N/self.Nfeeds)]\\n self.Nsamples += int(N)\",\n \"def __get_dataset_size(input_):\\n in_type = __get_input_type(input_)\\n b_unit = 1024.0 * 1024.0\\n if in_type == \\\"numpy_array\\\":\\n size_in_MB = input_.nbytes / b_unit\\n elif in_type == \\\"hdf\\\":\\n size_in_MB = os.path.getsize(input_) / b_unit\\n else:\\n list_file = losa.find_file(input_ + \\\"/*.tif*\\\")\\n if list_file:\\n size_1_file = np.asarray(Image.open(list_file[0])).nbytes / b_unit\\n else:\\n size_1_file = 0.0\\n size_in_MB = len(list_file) * size_1_file\\n return size_in_MB\",\n \"def nbytes(self):\\n dtype = self.config[\\\"dtype\\\"]\\n if dtype is None:\\n return None\\n\\n size = reduce(mul, self.shape, 1)\\n nbytes = size * dtype.itemsize\\n\\n if getattr(self, \\\"masked\\\", True):\\n nbytes += size\\n\\n return nbytes\",\n \"def get_size(self, hdf):\\n return sum([sys.getsizeof(hdf[p]) for p in hdf.list_nodes()]) + sum(\\n [self.get_size(hdf[p]) for p in hdf.list_groups()]\\n )\",\n \"def data_size( self, groups ):\\n #if len(groups) == 0:\\n # return 0\\n return max( groups.values() )\",\n \"def nbytes(self):\\n # type: () -> int\\n size = 0\\n for chunk in self.data.chunks:\\n for buf in chunk.buffers():\\n size += buf.size\\n return size\",\n \"def dimensions():\",\n \"def num_elements(self):\\n return self.subset.num_elements()\",\n \"def get_size(self):\\n return self._surf.get_size()\",\n \"def count_data(self):\\n try:\\n ndata = len(self.x)\\n logger.info(\\\"Number of data points: {0}\\\".format(ndata))\\n except AttributeError:\\n logger.error(\\\"Data object has not been defined\\\")\\n ndata = 0\\n return ndata\",\n \"def get_length(self):\\n if self.opt.num_buckets > 1:\\n return sum([len(bucket) for bucket in self.data])\\n else:\\n return len(self.data)\",\n \"def __len__( self ):\\n return len( self._raster_data )\",\n \"def graph_data_size(self) -> int:\\n return int(self.graph_tuple_stats.graph_data_size or 0)\",\n \"def test_size(self) -> int:\\n return int(self.data_size * self.__test_fraction)\",\n \"def size(self) -> int:\\n return self.da.length()\",\n \"def size(self) -> int:\\n return self.da.length()\",\n \"def size(self) -> int:\\n return self.da.length()\",\n \"def size(self) -> int:\\n return self.da.length()\",\n \"def n_dims(self):\\n return len(self.dimensions)\",\n \"def size(self, batch):\\n x,y,m = batch \\n return sum([mm.sum() for mm in m])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8266003","0.76687074","0.7574417","0.75476074","0.7534628","0.7282379","0.72617334","0.7169072","0.7134597","0.7131639","0.71055424","0.7064898","0.70379966","0.7025604","0.7004166","0.6994787","0.69689655","0.69596523","0.6953735","0.69417727","0.6908508","0.6892053","0.6892053","0.6887908","0.6852594","0.6827202","0.68255895","0.68230164","0.6822927","0.6802025","0.67960024","0.67942625","0.6772995","0.6762101","0.67555916","0.67230934","0.6718384","0.67155033","0.6714495","0.6701687","0.67016155","0.66925704","0.6690807","0.6690481","0.66859525","0.6684816","0.66835886","0.6649728","0.6646967","0.66452","0.6641968","0.6641089","0.66361624","0.66359687","0.66357076","0.6631694","0.6624262","0.66186744","0.6618538","0.6608617","0.6606963","0.6606518","0.6605088","0.6602196","0.65952927","0.6584458","0.6578666","0.6576369","0.65705764","0.65597665","0.65564764","0.6554649","0.65545905","0.65401906","0.6531687","0.65247244","0.6523251","0.6522284","0.65190244","0.6507744","0.6505202","0.6502565","0.6500292","0.649602","0.64862347","0.64839983","0.64818263","0.64766675","0.64760697","0.6474356","0.64719796","0.6464944","0.64612925","0.64581925","0.64547074","0.64547074","0.64547074","0.64547074","0.6449409","0.64456713"],"string":"[\n \"0.8266003\",\n \"0.76687074\",\n \"0.7574417\",\n \"0.75476074\",\n \"0.7534628\",\n \"0.7282379\",\n \"0.72617334\",\n \"0.7169072\",\n \"0.7134597\",\n \"0.7131639\",\n \"0.71055424\",\n \"0.7064898\",\n \"0.70379966\",\n \"0.7025604\",\n \"0.7004166\",\n \"0.6994787\",\n \"0.69689655\",\n \"0.69596523\",\n \"0.6953735\",\n \"0.69417727\",\n \"0.6908508\",\n \"0.6892053\",\n \"0.6892053\",\n \"0.6887908\",\n \"0.6852594\",\n \"0.6827202\",\n \"0.68255895\",\n \"0.68230164\",\n \"0.6822927\",\n \"0.6802025\",\n \"0.67960024\",\n \"0.67942625\",\n \"0.6772995\",\n \"0.6762101\",\n \"0.67555916\",\n \"0.67230934\",\n \"0.6718384\",\n \"0.67155033\",\n \"0.6714495\",\n \"0.6701687\",\n \"0.67016155\",\n \"0.66925704\",\n \"0.6690807\",\n \"0.6690481\",\n \"0.66859525\",\n \"0.6684816\",\n \"0.66835886\",\n \"0.6649728\",\n \"0.6646967\",\n \"0.66452\",\n \"0.6641968\",\n \"0.6641089\",\n \"0.66361624\",\n \"0.66359687\",\n \"0.66357076\",\n \"0.6631694\",\n \"0.6624262\",\n \"0.66186744\",\n \"0.6618538\",\n \"0.6608617\",\n \"0.6606963\",\n \"0.6606518\",\n \"0.6605088\",\n \"0.6602196\",\n \"0.65952927\",\n \"0.6584458\",\n \"0.6578666\",\n \"0.6576369\",\n \"0.65705764\",\n \"0.65597665\",\n \"0.65564764\",\n \"0.6554649\",\n \"0.65545905\",\n \"0.65401906\",\n \"0.6531687\",\n \"0.65247244\",\n \"0.6523251\",\n \"0.6522284\",\n \"0.65190244\",\n \"0.6507744\",\n \"0.6505202\",\n \"0.6502565\",\n \"0.6500292\",\n \"0.649602\",\n \"0.64862347\",\n \"0.64839983\",\n \"0.64818263\",\n \"0.64766675\",\n \"0.64760697\",\n \"0.6474356\",\n \"0.64719796\",\n \"0.6464944\",\n \"0.64612925\",\n \"0.64581925\",\n \"0.64547074\",\n \"0.64547074\",\n \"0.64547074\",\n \"0.64547074\",\n \"0.6449409\",\n \"0.64456713\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7754449"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":94995,"cells":{"query":{"kind":"string","value":"set the voxel sizes of the images that are read"},"document":{"kind":"string","value":"def setVoxelSize(self, vxs):\n\t\tself.voxelsize = vxs\n\t\ta, b, c = vxs\n\t\tself.spacing = [1, b / a, c / a]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _assign_sizes(self):","def setinputsizes(self, sizes):\n pass","def setImageDimensions(*args):","def update_size(self):\n self.size = self.image.size\n self.width, self.height = self.size","def set_size(self, size=None):\n if not size:\n size = self.output_size\n self.img = cv2.resize(self.img, size)\n self.update_image()\n self.update_size()","def voxel_size(self):\n # Set experiment if unset:\n if self._exp is None:\n self._populate_exp()\n\n # Set cframe if unset:\n if self._coord_frame is None:\n self._populate_coord_frame()\n\n if self.axis_order == AxisOrder.XYZ:\n vox_size = (\n self._coord_frame.x_voxel_size,\n self._coord_frame.y_voxel_size,\n self._coord_frame.z_voxel_size,\n )\n elif self.axis_order == AxisOrder.ZYX:\n vox_size = (\n self._coord_frame.z_voxel_size,\n self._coord_frame.y_voxel_size,\n self._coord_frame.x_voxel_size,\n )\n return (vox_size, self._coord_frame.voxel_unit)","def set_num_images(self,num_images):\n for roi in self.rois:\n roi.set_num_images(num_images)\n self.num_images = num_images","def set_sizes(self, sizes):\n self._sizes = sizes","def getVoxelSize(self):\n\t\treturn self.voxelsize","def voxel_size(self):\n return self.calculation.voxel_size","def update_dimensions(self):\n self.chunk = numpy.full((self.current_height, self.current_width), fill_value=Constants.VALUE_INITIALIZER,\n dtype=\"int16\")","def _SetDimensions(self):\n self._size = 0\n for variable_ndarray in self._layer.get_weights():\n size = variable_ndarray.size\n self._dimensions.append((variable_ndarray.shape, size))\n self._size += size","def voxel_count(self):\n return self.cols * self.rows * self.sections","def get_raw_image_sizes() -> set:\n sizes = set()\n data = SUNRGBDTrainDataset(True, augment=False)\n for i in range(len(data)):\n sizes.add(data[i][0].shape)\n return sizes","def test_correct_image_size(location):\n chunkloc = resave_to_chunks(root=location[\"dir\"],\n n_imgs=10,\n output_stem=location[\"stem\"])\n\n loaded = np.load(chunkloc)\n assert len(loaded.files) > 0\n\n first = loaded[loaded.files[0]]\n assert first.shape != ()\n assert first.shape == (520, 696)","def setup(self):\n self.debug(\"Setup ..\")\n\n if self.pipeline.settings.useHardwarePCF:\n self.error(\n \"Global Illumination does not work in combination with PCF!\")\n import sys\n sys.exit(0)\n return\n\n self.settings = VoxelSettingsManager()\n self.settings.loadFromFile(join(self.sceneRoot, \"voxels.ini\"))\n\n self.debug(\n \"Loaded voxels, grid resolution is\", self.settings.GridResolution)\n\n self.gridScale = self.settings.GridEnd - self.settings.GridStart\n self.voxelSize = self.gridScale / float(self.settings.GridResolution)\n self.entrySize = Vec2(\n 1.0 / float(self.settings.StackSizeX), 1.0 / float(self.settings.StackSizeY))\n self.frameIndex = 0\n\n invVoxelSize = Vec3(\n 1.0 / self.voxelSize.x, 1.0 / self.voxelSize.y, 1.0 / self.voxelSize.z)\n invVoxelSize.normalize()\n self.normalizationFactor = invVoxelSize / \\\n float(self.settings.GridResolution)\n\n # Debugging of voxels, VERY slow\n self.debugVoxels = False\n\n if self.debugVoxels:\n self.createVoxelDebugBox()\n\n # Load packed voxels\n packedVoxels = Globals.loader.loadTexture(\n join(self.sceneRoot, \"voxels.png\"))\n packedVoxels.setFormat(Texture.FRgba8)\n packedVoxels.setComponentType(Texture.TUnsignedByte)\n # packedVoxels.setKeepRamImage(False)\n\n # Create 3D Texture to store unpacked voxels\n self.unpackedVoxels = Texture(\"Unpacked voxels\")\n self.unpackedVoxels.setup3dTexture(self.settings.GridResolution, self.settings.GridResolution, self.settings.GridResolution,\n Texture.TFloat, Texture.FRgba8)\n self.unpackedVoxels.setMinfilter(Texture.FTLinearMipmapLinear)\n self.unpackedVoxels.setMagfilter(Texture.FTLinear)\n\n self.unpackVoxels = NodePath(\"unpackVoxels\")\n self.unpackVoxels.setShader(\n BetterShader.loadCompute(\"Shader/GI/UnpackVoxels.compute\"))\n\n print \"setting inputs ..\"\n self.unpackVoxels.setShaderInput(\"packedVoxels\", packedVoxels)\n print \"setting inputs ..\"\n self.unpackVoxels.setShaderInput(\n \"stackSizeX\", LVecBase3i(self.settings.StackSizeX))\n print \"setting inputs ..\"\n self.unpackVoxels.setShaderInput(\n \"gridSize\", LVecBase3i(self.settings.GridResolution))\n print \"setting inputs ..\"\n self.unpackVoxels.setShaderInput(\"destination\", self.unpackedVoxels)\n print \"executing shader ..\"\n self._executeShader(\n self.unpackVoxels, self.settings.GridResolution / 8, self.settings.GridResolution / 8, self.settings.GridResolution / 8)\n\n print \"creating direct radiance texture ..\"\n # Create 3D Texture to store direct radiance\n self.directRadianceCache = Texture(\"Direct radiance cache\")\n self.directRadianceCache.setup3dTexture(self.settings.GridResolution, self.settings.GridResolution, self.settings.GridResolution,\n Texture.TInt, Texture.FR32i)\n\n self.directRadiance = Texture(\"Direct radiance\")\n self.directRadiance.setup3dTexture(self.settings.GridResolution, self.settings.GridResolution, self.settings.GridResolution,\n Texture.TFloat, Texture.FRgba16)\n\n print \"setting texture states ..\"\n for prepare in [self.directRadiance, self.unpackedVoxels]:\n prepare.setMagfilter(Texture.FTLinear)\n prepare.setMinfilter(Texture.FTLinearMipmapLinear)\n prepare.setWrapU(Texture.WMBorderColor)\n prepare.setWrapV(Texture.WMBorderColor)\n prepare.setWrapW(Texture.WMBorderColor)\n prepare.setBorderColor(Vec4(0,0,0,1))\n\n self.unpackedVoxels.setBorderColor(Vec4(0))\n # self.directRadiance.setBorderColor(Vec4(0))\n\n self.populateVPLNode = NodePath(\"PopulateVPLs\")\n self.clearTextureNode = NodePath(\"ClearTexture\")\n self.copyTextureNode = NodePath(\"CopyTexture\")\n self.generateMipmapsNode = NodePath(\"GenerateMipmaps\")\n self.convertGridNode = NodePath(\"ConvertGrid\")\n\n\n if False:\n surroundingBox = Globals.loader.loadModel(\n \"Models/CubeFix/Model.egg\")\n surroundingBox.setPos(self.settings.GridStart)\n surroundingBox.setScale(self.gridScale)\n\n # surroundingBox.setTwoSided(True)\n surroundingBox.flattenStrong()\n surroundingBox.reparentTo(Globals.render)\n\n self.bindTo(self.populateVPLNode, \"giData\")\n self.reloadShader()\n\n self._generateMipmaps(self.unpackedVoxels)","def _set_x_block_size(self):\n self._scene_gen.block_dimensions = (self._block_size_x_spinbox.value(),\n self._scene_gen.block_dimensions[Y],\n self._scene_gen.block_dimensions[Z])\n self._refresh_view()","def setinputsizes(self, sizes):\r\n if self._closed:\r\n raise Error('The cursor has been closed.')\r\n if self.connection._closed:\r\n raise Error('The connection to the database has been closed.')\r\n else:\r\n pass","def __init__(self, nb_sub_images, window_size, recovery, image_horiz_size):\n self.nb_sub_images = nb_sub_images\n self.window_size = window_size\n self.recovery = recovery\n self.image_horiz_size = image_horiz_size","def set_image_data(self, data_file):\n # TODO: support other file formats, like hd5 and maybe raw binary?\n import scipy.io\n self.image_data = np.atleast_3d(scipy.io.loadmat(data_file).values()[0])\n if self.image_data.ndim == 3:\n self.image_data = self.image_data.reshape(self.image_data.shape + (1,))\n # TODO: confirm that this voxel reordering is necessary. Maybe lean on the recon\n # folks to standardize thier voxle order? Might also look at\n self.image_data = self.image_data.transpose((1,0,2,3))[::-1,:,::-1,:]\n\n if self.image_data.shape[0] != self.size_x or self.image_data.shape[1] != self.size_y:\n msg = 'Image matrix discrepancy. Fixing the header, assuming image_data is correct...'\n self.log and self.log.warning(msg) or print(msg)\n self.size_x = self.image_data.shape[0]\n self.size_y = self.image_data.shape[1]\n self.mm_per_vox[0] = float(self.fov[0] / self.size_x)\n self.mm_per_vox[1] = float(self.fov[1] / self.size_y)\n if self.image_data.shape[2] != self.num_slices:\n msg = 'Image slice count discrepancy. Fixing the header, assuming image_data is correct...'\n self.log and self.log.warning(msg) or print(msg)\n self.num_slices = self.image_data.shape[2]\n if self.image_data.shape[3] != self.num_timepoints:\n msg = 'Image time frame discrepancy (header=%d, array=%d). Fixing the header, assuming image_data is correct...' % (self.num_timepoints, self.image_data.shape[3])\n self.log and self.log.warning(msg) or print(msg)\n self.num_timepoints = self.image_data.shape[3]","def set_default_parameters(self):\n super().set_default_parameters()\n if not \"region_size\" in vars(self):\n self.region_size = 0.08\n if not \"RGB_bands\" in vars(self):\n self.RGB_bands = [\"B4\",\"B3\",\"B2\"]\n if not \"split_RGB_images\" in vars(self):\n self.split_RGB_images = True\n # in PROCESSED dir we expect RGB. NDVI, BWNDVI\n self.num_files_per_point = 3","def countDataSize(self,filename):\n \n d = h5py.File(filename,'r')\n features = d['spectrometer/features'][:]\n select = self.selectData(features.astype(float), self.ifeature, d)\n N = len(features[select])\n d.close()\n\n N = (N//self.offsetLen) * self.offsetLen\n\n N = N*self.Nfeeds\n\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\n self.datasizes += [int(N/self.Nfeeds)]\n self.Nsamples += int(N)","def countDataSize(self,filename):\n \n try:\n d = h5py.File(filename,'r')\n except:\n print(filename)\n return \n\n N = 0\n scan_edges = d['level2/Statistics/scan_edges'][:]\n for (start,end) in scan_edges:\n N += (end-start)//self.offsetLen * self.offsetLen\n d.close()\n\n N = N*self.Nfeeds\n\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\n self.datasizes += [int(N/self.Nfeeds)]\n self.Nsamples += int(N)","def get_num_of_images(self):","def _set_pixel_size(self) -> None:\n # Not Pansharpened images\n if self.band_combi == Sv1BandCombination.PMS:\n # TODO: manage default resolution for PAN band ?\n self.pixel_size = self._ms_res\n # Pansharpened images\n else:\n self.pixel_size = self._pan_res","def resize(self, **kwargs):\n\n if self.image is None:\n raise ValueError('self.image is None! The image has to be initialized!')\n\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n self.image = ndimage.interpolation.zoom(self.image * 1., **kwargs)\n\n # if size <= 3, pad with zeros\n\n if np.min(self.image.shape) < 5:\n self.image = np.pad(self.image, pad_width=3, mode='constant', constant_values=0)\n\n if self.image.max() > 0:\n self.image = rescale_intensity(self.image, out_range=(0, 255))\n\n if 'Voxel size x' in self.metadata.index and 'Voxel size y' in self.metadata.index \\\n and 'Voxel size z' in self.metadata.index:\n new_voxel_size = np.array([self.metadata['Voxel size z'], self.metadata['Voxel size y'],\n self.metadata['Voxel size x']]) / kwargs['zoom']\n self.metadata['Voxel size'] = str(new_voxel_size)\n self.metadata['Voxel size z'], self.metadata['Voxel size y'], self.metadata['Voxel size x'] = new_voxel_size\n\n return self.image","def set_pic_size(self, im_name):\n im_vals = np.genfromtxt(im_name, delimiter=self.delim)\n self.pic_width = int(np.size(im_vals[0]) - 1) # the first column of ASCII image is row number\n try: self.pic_height = int(np.size(im_vals[:,0])) \n except IndexError: \n self.pic_width = int(np.size(im_vals) - 1)\n self.pic_height = 1\n self.create_rect_mask()\n return self.pic_width, self.pic_height","def setFilmSize(self, size_x, size_y):\n self.lens.setFilmSize(size_x, size_y)\n self.rebuildMatrixCache()","def set_size(self, w, h):\n\t\tpass","def set_size(self, width, height):\r\n \r\n self.image = pygame.transform.scale(self.image, (width, height))\r\n self.rect = self.image.get_rect()","def setImageSize(cls, width, height):\n\t\tcls._width = width\n\t\tcls._height = height","def dimensions():","def chunksize(self, value):\n\n self.data.chunksize = int(value)\n self.mask.chunksize = int(value)","def __init__(self, image_size, heatmap_size):\n super(ProjectLayer, self).__init__()\n self.image_size = image_size\n self.heatmap_size = heatmap_size\n if isinstance(self.image_size, int):\n self.image_size = [self.image_size, self.image_size]\n if isinstance(self.heatmap_size, int):\n self.heatmap_size = [self.heatmap_size, self.heatmap_size]","def updateSize(self, *args):\n width = self.width.get()\n height = self.height.get()\n self.initialXScale.config(to=width)\n self.initialYScale.config(to=height)\n # error check that state is not outside bounds\n for ball, state in self.ballStates.items():\n if state[0] > width:\n state[0] = width\n if state[1] > height:\n state[1] = height","def sizes(options):\n # import data\n pixels = dict() # volumes are given in #pixels\n snap_mask = \"/net/astrogate/export/astrodata/jgacon/filex/processing/\" \\\n \"export/f8_h50_v100_objs_snap_%d.csv\"\n snap_ids = np.arange(2,28+1)\n z = snapid2z(snap_ids)\n print z\n\n for id in snap_ids:\n snap = snap_mask % (id - 1) # fix: snap number one too low in filename\n pixels[id] = np.genfromtxt(snap)[1:-1,1] # row 2 contains volumes\n # rm void & halo volumes\n\n # visualise\n if \"err\" in options.keys():\n nums = np.array([pixels[id].size for id in snap_ids])\n avgs = np.array([np.mean(pixels[id]) for id in snap_ids])\n mods = np.array([st.mode(pixels[id])[0][0] for id in snap_ids])\n meds = np.array([np.median(pixels[id]) for id in snap_ids])\n stds = np.array([np.std(pixels[id]) for id in snap_ids])\n\n print mods\n print mods.shape\n\n plt.figure()\n plt.title(\"Sizes of filaments as function of redshift\")\n plt.xlabel(\"Redshift $z$\")\n plt.xticks(snap_ids[::3], z[::3])\n\n plt.ylabel(\"Size in #pixels\")\n\n plt.errorbar(snap_ids, avgs, yerr=stds, label=\"Mean\")\n plt.plot(snap_ids, mods, \"g\", label=\"Mode\")\n plt.plot(snap_ids, meds, \"c\", label=\"Median\")\n plt.legend(loc=\"best\")\n\n plt.twinx()\n plt.ylabel(\"#Filaments\", color=\"r\")\n plt.tick_params(\"y\", colors=\"r\")\n\n plt.plot(snap_ids, nums, \"r--\")\n\n plt.savefig(options[\"err\"])\n\n if \"dist\" in options.keys():\n targets = np.array([5,10,15,20,25])\n plt.figure()\n plt.title(\"Volume distribution of filaments\")\n plt.xlabel(\"Volume $V$ in #pixels\")\n plt.ylabel(\"#Element with $V$ / Total #Elements\")\n plt.xlim([0,1000])\n for target in targets:\n sns.kdeplot(pixels[target], label=\"$z$ = %f\" % snapid2z(target))\n plt.legend(loc=\"best\")\n plt.savefig(options[\"dist\"])\n\n if \"dist_inter\" in options.keys():\n default = snap_ids[-1]\n fig, ax = plt.subplots()\n plt.subplots_adjust(bottom=0.25)\n sns.kdeplot(pixels[int(default - 2)], ax=ax)\n plt.xlim([0, 1000])\n plt.ylim([0, 0.01])\n plt.xlabel(\"Volume $V$ of filaments in #pixels\")\n plt.ylabel(\"#Filaments with volume $V$ / Total #Filaments\")\n\n nums = np.array([pixels[id].size for id in snap_ids])\n ax2 = ax.twinx()\n ax2.set_ylabel(\"#Filaments\", color=\"r\", alpha=0.5)\n ax2.tick_params(axis=\"y\", labelcolor=\"r\")\n ax2_x = np.linspace(0, 1000, nums.size)\n ax2.plot(ax2_x, nums, \"r--\", alpha=0.5)\n point, = ax2.plot(ax2_x[default - 2], nums[default - 2], \"ro\", alpha=0.5)\n\n axcolor = 'lightgoldenrodyellow'\n axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)\n sid = Slider(axfreq, \"ID\", 2, 28, valinit=default, valstep=1)\n ax.set_title(\"$z$ = %f\" % snapid2z(default))\n\n def update(val):\n id = sid.val\n\n print id\n #ax.clear()\n ax.set_ydata()\n ax.set_xdata()\n ax.set_title(\"$z$ = %f\" % snapid2z(int(id)))\n ax.set_xlim([0,1000])\n ax.set_ylim([0, 0.01])\n sns.kdeplot(pixels[int(id)], ax=ax)\n point.set_xdata(ax2_x[int(id) - 2])\n point.set_ydata(nums[int(id) - 2])\n fig.canvas.draw_idle()\n sid.on_changed(update)\n\n plt.show()\n\n\n if \"hist\" in options.keys():\n conc = None\n for id, vols in pixels.iteritems():\n data = np.empty((vols.size, 2))\n data[:,0] = id\n data[:,1] = vols\n\n if conc is None:\n conc = data\n else:\n conc = np.vstack((conc, data))\n\n plt.figure()\n plt.hist2d(conc[:,0], conc[:,1], bins=(snap_ids.size, 1000))\n plt.ylim([100,400])\n plt.savefig(options[\"hist\"])","def SetSize(self, m: 'unsigned int', n: 'unsigned int') -> \"void\":\n return _itkArray2DPython.itkArray2DD_SetSize(self, m, n)","def get_image_size(self):","def apply(self):\n self.grid_size = self.values[0]","def _resize(self, size: Tuple[int, int], axis: int = None) -> None:\n\t\tif self.name == \"\":\n\t\t\tself.ds._file['/matrix'].resize(size, axis)\n\t\telse:\n\t\t\tself.ds._file['/layers/' + self.name].resize(size, axis)","def GetVoxelSize(vDataSet):\r\n nx = vDataSet.GetSizeX()\r\n ny = vDataSet.GetSizeY()\r\n nz = vDataSet.GetSizeZ()\r\n\r\n if nx > 0: nx = abs(vDataSet.GetExtendMaxX()-vDataSet.GetExtendMinX())/nx;\r\n if ny > 0: ny = abs(vDataSet.GetExtendMaxY()-vDataSet.GetExtendMinY())/ny;\r\n if nz > 0: nz = abs(vDataSet.GetExtendMaxZ()-vDataSet.GetExtendMinZ())/nz;\r\n\r\n return nx,ny,nz","def _get_box_sizes(self, image_info, cat):\n\n\n file_id=0\n impath=image_info['image_path'][file_id].strip()\n ext=image_info['image_ext'][file_id]\n wcs_data = fitsio.read_header(impath, ext=ext)\n wcs = eu.wcsutil.WCS(wcs_data)\n\n\n jacob = wcs.get_jacobian(100,100)\n dudcol, dudrow, dvdcol, dvdrow = jacob\n\n det = dvdrow*dudcol - dvdcol*dudrow\n pixel_scale = np.sqrt(abs(det))\n print('found pixel scale:',pixel_scale)\n box_size = cat['box_size_arcsec']/pixel_scale\n\n # clip to range\n box_size.clip(\n min=self['min_box_size'],\n max=self['max_box_size'],\n out=box_size,\n )\n box_size = box_size.astype('i4')\n\n w,=np.where( ( (box_size % 2) != 0 ) )\n if w.size > 0:\n box_size[w] += 1\n\n return box_size","def __init__(self, sizes, image_size):\n super(CraterNetwork, self).__init__(sizes);\n self.im_size = image_size\n self.validating = False","def SetSize(self, m: 'unsigned int', n: 'unsigned int') -> \"void\":\n return _itkArray2DPython.itkArray2DUI_SetSize(self, m, n)","def onSetToFourthSize(self, evt):\n\t\tself.halfResampleZ.Enable(0)\n\t\tself.fourthResampleZ.Enable(1)\n\t\tif self.dataUnits:\n\t\t\tzf = 1\n\t\t\tx, y, z = self.dataUnits[0].dataSource.getOriginalDimensions()\n\t\t\t\n\t\t\tif self.fourthResampleZ.GetValue():\n\t\t\t\tzf = 0.25\n\t\t\tself.currSize = int(0.25 * x), int(0.25 * y), int(zf * z) \n\t\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\n\t\t\tobj.Enable(0)","def scan_size(self):\n max_memory = 10e9/4 # because 32-bit floats will be used\n memory = 0\n for f in self.filenames:\n img = cv2.imread(f, int(self.color))\n if img is not None:\n m = 1\n for dim in img.shape:\n m *= dim\n memory += m\n else:\n print('error opening %s' % f)\n print('size is %s bytes' % memory)\n return memory <= max_memory","def scan_size(self):\n max_memory = 10e9/4 # because 32-bit floats will be used\n memory = 0\n for f in self.filenames:\n img = cv2.imread(f, int(self.color))\n if img is not None:\n m = 1\n for dim in img.shape:\n m *= dim\n memory += m\n else:\n print('error opening %s' % f)\n print('size is %s bytes' % memory)\n return memory <= max_memory","def scan_size(self):\n max_memory = 10e9/4 # because 32-bit floats will be used\n memory = 0\n for f in self.filenames:\n img = cv2.imread(f, int(self.color))\n if img is not None:\n m = 1\n for dim in img.shape:\n m *= dim\n memory += m\n else:\n print('error opening %s' % f)\n print('size is %s bytes' % memory)\n return memory <= max_memory","def getDimensions():","def SetSize(self, m: 'unsigned int', n: 'unsigned int') -> \"void\":\n return _itkArray2DPython.itkArray2DF_SetSize(self, m, n)","def get_image_sizes():\n widths = []\n heights = []\n\n from settings import folders_location\n for individual_folder_name in listdir(folders_location):\n individual_training_folder_path = folders_location + individual_folder_name + \"/training/\"\n\n image_paths = listdir(individual_training_folder_path)\n for image_path in image_paths:\n img = cv2.imread(individual_training_folder_path + image_path)\n\n height, width, channel = img.shape\n widths.append(width)\n heights.append(height)\n\n print(individual_training_folder_path + image_path)\n\n print(\"Min: %s, Max: %s\" % (np.min(widths), np.max(widths)))\n print(\"Average: %s\" % (np.average(widths)))\n\n return widths","def set_data_size(self, num_bytes):\n self.model.data_size = num_bytes\n self.refresh_memory()","def set_variables(self):\n self.feat_size = None # Set this in your inherited class\n raise NotImplementedError(\"set_variables() is not implemented\")","def set_element_dimensions(self, size_x, size_y, size_z):\n size_x = 1.0 * size_x\n size_y = 1.0 * size_y\n size_z = 1.0 * size_z\n x = np.repeat(size_x, self.numelements)\n y = np.repeat(size_y, self.numelements)\n z = np.repeat(size_z, self.numelements)\n self.dimensions = g.Points.from_xyz(x, y, z)\n return self","def estimate_size(self, datasets):\n datasets = Datasets(datasets)\n \n# self.fit.run(datasets)\n\n if self.size_values:\n self.size_parameter.scan_values = self.size_values.to_value(self.size_parameter.unit)\n self.size_parameter.scan_min = self.size_min.to_value(self.size_parameter.unit)\n self.size_parameter.scan_max = self.size_max.to_value(self.size_parameter.unit)\n self.size_parameter.scan_n_values = self.size_n_values\n \n result = super().run(datasets, self.size_parameter)\n return result","def __len__(self):\n return self._num_samples_per_file * len(self._files) // self._world_size","def resize_images(self, images):\n \n img_list = []\n \n for img in images:\n \n yield np.resize(img, (64, 64, 3))","def SetImageSize(self,x=IS.GET_IMAGE_SIZE_X_MAX,y=0):#non-zero ret\r\n r = CALL(\"SetImageSize\",self,INT(x),INT(y))\r\n if x & 0x8000 == 0x8000:\r\n return self.CheckForNoSuccessError(r)\r\n return self.CheckForSuccessError(r)","def __init__(self, pool_size):\n self.pool_size = pool_size\n if self.pool_size > 0: # create an empty pool\n self.num_imgs = 0\n self.images = []","def _get_image_size(self):\n return (3, 224, 224)","def GetTextureDimensions(self):\n ...","def set_size(self, size):\n \n self.width = size[0]\n self.height = size[1]","def set_size(self, mode):\n return len(self.data_index[mode])","def set_point_size(self, point_size=0.0):\r\n for b in self.buf:\r\n b.unib[8] = point_size","def load(self):\n\n # get files in folder\n files = [f for f in listdir(self.data_path)]\n print(\"loading images from folder: %s\" % self.data_path)\n\n images = []\n image_targets = []\n for f in files:\n filepath = path.join(self.data_path, f)\n images.append(io.imread(filepath, as_grey=True))\n image_targets.append(self.target)\n\n # define new size and resize images\n new_size = (2 ** self.size_exponent, 2 ** self.size_exponent)\n for i in range(0, len(images)):\n # images[i] = transform.resize(images[i], new_size)\n images[i] = misc.imresize(images[i], new_size) / 16\n\n self.images = images\n self.targets = image_targets","def initial_resizing(fr_raw_data_path, fr_data_path, dim=300):\n with h5py.File(fr_raw_data_path, 'r') as data:\n images = resize_array(np.asarray(data['images'].value), dim=dim)\n labels = data['labels'].value\n \n with h5py.File(fr_data_path, 'w') as f:\n f.create_dataset('images', data=images)\n\n with h5py.File(fr_raw_data_path, 'r') as data: \n f.copy(data['fri_data'], 'fri_data')\n f.copy(data['frii_data'], 'frii_data')\n f.copy(data['labels'], 'labels')","def size(self, val):\n self.width = val\n self.height = val","def resize(self):\n pass","def __init__(self, size=(2, 2), **kwargs):\n super(MaxUnpooling2D, self).__init__(**kwargs)\n self.size = size","def __len__(self):\n return self.num_images","def __len__(self):\n return self.num_images","def __len__(self):\n return self.num_images","def __len__(self):\n return self.num_images","def __len__(self):\n return self.num_images","def set_num_images(self,num_images):\n if num_images != self.num_images:\n self.counts = [{} for _ in range(num_images)]\n\n for _ in range(num_images,len(self.thresholds)): # delete unneeded thresholds\n self.thresholds.pop()\n for _ in range(len(self.thresholds), num_images): # make new thresholds\n self.thresholds.append(self.default_threshold)\n\n for _ in range(num_images,len(self.autothreshs)): # delete unneeded autothreshs\n self.autothreshs.pop()\n for _ in range(len(self.autothreshs), num_images): # make new autothreshs\n self.autothreshs.append(self.default_autothresh)\n\n self.num_images = num_images","def get_voxel_size(path: str) -> float:\n dcm = pydicom.dcmread(path, force=True)\n x_str, y_str = dcm.PixelSpacing\n x = Decimal(str(x_str))\n y = Decimal(str(y_str))\n z = Decimal(str(dcm.SpacingBetweenSlices))\n print(float(x * y * z))\n return float(x * y * z)","def setUp(self):\n self.gray_image = np.ndarray((100, 200), dtype=np.uint8)\n self.rgb_image = np.ndarray((100, 200, 3), dtype=np.uint8)","def scale(self, size=128):\n scale_factor = size / max(self.voxels.shape)\n self.voxels = ndimage.zoom(self.voxels, scale_factor)\n self.point_position = self.point_position * scale_factor\n self.voxel_size = False # To ignore this\n \n return(self)","def setImages( self, event_key, images ):\n print \"event index\",event_key[0]\n self.run = event_key[1]\n self.subrun = event_key[2]\n self.event_num = event_key[3]\n print self.run,self.subrun,self.event_num\n self.images = images\n #print self.images.img_v\n #for img in self.images.img_v:\n # print img.shape\n self.labeltools.setImage( event_key[0], self.images )","def _set_x_size(self):\n self._level_gen.size = (self._level_size_x_spinbox.value(),\n self._level_gen.size[Y],\n self._level_gen.size[Z])\n self._refresh_view()","def __CalculateSliceSize(self, readShapeZYX):\n # readShapeZYX is the dimension of the data we must READ to fill the required output area;\n # i.e .the fill area plus margins. If we're filling globally it's the same thing.\n dataBPP = 4\n memLimit = self._jobDetails.MemTargetBytes\n outputsBPP = dataBPP * 2 + 1 # the output data, distances, and flags\n # approximate total number of pixels we can read for each file\n sliceSqrd = memLimit / (readShapeZYX[0] * (dataBPP + outputsBPP))\n # not implementing slicing in y dimension so xSize is total pixels / total height\n sliceXSize = sliceSqrd / readShapeZYX[1]\n return sliceXSize","def updateSize(self, *args):\n return None","def onSize(self, event): \n\t\tw, h = self.GetClientSizeTuple()\n\t\tself.tree.SetDimensions(0, 0, w, h)","def set_dimensions(self, fshape=1, params=np.array([0., 0., 0., 0.])):\n self.FHIT_C = 1\n self.FSHAPE = fshape\n self.RLEN1 = params[0]\n self.RLEN2 = params[1]\n self.RWIDX1 = params[2]\n self.RWIDX2 = params[3]","def test_full_resize(self):\n number_of_pixels = 300\n destination = base_path +'/test_data/rendering_tests/resized_images/'\n source_folder = base_path + '/test_data/rendering_tests/filter_database/'\n\n\n for the_file in os.listdir(destination):\n file_path = os.path.join(destination, the_file)\n if os.path.isfile(file_path):\n os.unlink(file_path)\n\n\n self.assertEqual(0, len(os.listdir(destination)))\n rb.find_all_files(number_of_pixels,source_folder, destination)\n self.assertEqual(6, len(os.listdir(destination)))\n for the_file in os.listdir(destination):\n file_path = os.path.join(destination,the_file)\n with Image.open(file_path) as f:\n self.assertNotEqual(number_of_pixels+5, f.size[0])\n self.assertNotEqual(number_of_pixels+5, f.size[1])\n # the above checks that the size does not vary as needed\n # probably not necessary\n self.assertEqual(number_of_pixels, f.size[0])\n self.assertEqual(number_of_pixels, f.size[1])","def size(img):\n\treturn img.size","def _set_z_block_size(self):\n self._scene_gen.block_dimensions = (self._scene_gen.block_dimensions[X],\n self._scene_gen.block_dimensions[Y],\n self._block_size_z_spinbox.value())\n self._refresh_view()","def update_resize(self, viewer, dims):\n self.recalc(viewer)","def setSurfaceSize(xmin, xmax, ymin, ymax):\n dislin.sursze(xmin, xmax, ymin, ymax)","def set_pool_size(self, pool_size):\n self._semantic_decoder.set_pool_size(pool_size)\n if self._instance_decoder is not None:\n self._instance_decoder.set_pool_size(pool_size)","def __init__(self, images, batch_size, ctx, multisp):\n self.ctx = ctx\n self.batch_size = batch_size\n self.images = []\n self.multisp = multisp\n\n self.images=images\n\n if self.images:\n self.channels, self.imgsize, _ = self._read_img(self.images[0]['data']).shape\n\n logging.info(\"Found a total of {} images\".format(len(self.images)))","def input_load(self):\n return self.nmos_size + self.pmos_size","def estimate_size(self, ixreader):\r\n raise NotImplementedError","def SetDimensions(self, p_int, p_int_1, p_int_2, p_int_3, p_int_4, p_int_5, p_int_6):\n ...","def setsize(self, size):\n self.__size = size","def testSize (self):\r\n \r\n perpixel = bytes_per_pixel [self.bih_vals [bih_BitCount]]\r\n width = self.bih_vals [bih_Width]\r\n height = self.bih_vals [bih_Height]\r\n expected = self.bih_vals [bih_SizeImage]\r\n\r\n # Rows always have multiples of 4 bytes\r\n \r\n padding = 3 - ((perpixel * width + 3) % 4)\r\n size = (width * perpixel + padding) * height\r\n\r\n if not size == expected:\r\n print \"Calculated size = %d (<> %d)\" % (size, expected)\r\n print \"***** File size error *****\"","def __len__(self):\n return math.ceil(self.number_of_images / self.batch_size)","def input_image_size(interpreter):\n _, height, width, channels = interpreter.get_input_details()[0]['shape']\n return width, height, channels","def __init__(self, *, points, n_x=1, n_y=1, n_z=1, size_x=None, size_y=None, size_z=None, range=None, **kwargs):\n super().__init__(points=points, **kwargs)\n\n if size_x is None or size_y is None or size_z is None:\n print('WARNING: when computing a voxelgrid for running a Neural net, voxel sizes should be homogeneous among different point clouds or the neural network wont learn spatial relationships. To ensure this, use (size_x, size_y, size_z) instead of (n_x, n_y, n_z)')\n\n self.x_y_z = [n_x, n_y, n_z]\n self.sizes = np.array([size_x, size_y, size_z])\n\n if range is None:\n self.xyzmin = self.bounds[0]\n self.xyzmax = self.bounds[1]\n else: \n self.xyzmin = range[:3]\n self.xyzmax = range[3:]\n\n for n, size in enumerate(self.sizes):\n if size is None:\n continue\n\n # ensure that 'sizes' are respected by making the box bigger if necessary\n margin = size - ((self.xyzmax[n] - self.xyzmin[n]) % size)\n self.xyzmin[n] -= margin / 2\n self.xyzmax[n] += margin / 2\n self.x_y_z[n] = int(round((self.xyzmax[n] - self.xyzmin[n]) / size))","def setTestSampleSize(self, Ntest):\n self.Ntest = Ntest"],"string":"[\n \"def _assign_sizes(self):\",\n \"def setinputsizes(self, sizes):\\n pass\",\n \"def setImageDimensions(*args):\",\n \"def update_size(self):\\n self.size = self.image.size\\n self.width, self.height = self.size\",\n \"def set_size(self, size=None):\\n if not size:\\n size = self.output_size\\n self.img = cv2.resize(self.img, size)\\n self.update_image()\\n self.update_size()\",\n \"def voxel_size(self):\\n # Set experiment if unset:\\n if self._exp is None:\\n self._populate_exp()\\n\\n # Set cframe if unset:\\n if self._coord_frame is None:\\n self._populate_coord_frame()\\n\\n if self.axis_order == AxisOrder.XYZ:\\n vox_size = (\\n self._coord_frame.x_voxel_size,\\n self._coord_frame.y_voxel_size,\\n self._coord_frame.z_voxel_size,\\n )\\n elif self.axis_order == AxisOrder.ZYX:\\n vox_size = (\\n self._coord_frame.z_voxel_size,\\n self._coord_frame.y_voxel_size,\\n self._coord_frame.x_voxel_size,\\n )\\n return (vox_size, self._coord_frame.voxel_unit)\",\n \"def set_num_images(self,num_images):\\n for roi in self.rois:\\n roi.set_num_images(num_images)\\n self.num_images = num_images\",\n \"def set_sizes(self, sizes):\\n self._sizes = sizes\",\n \"def getVoxelSize(self):\\n\\t\\treturn self.voxelsize\",\n \"def voxel_size(self):\\n return self.calculation.voxel_size\",\n \"def update_dimensions(self):\\n self.chunk = numpy.full((self.current_height, self.current_width), fill_value=Constants.VALUE_INITIALIZER,\\n dtype=\\\"int16\\\")\",\n \"def _SetDimensions(self):\\n self._size = 0\\n for variable_ndarray in self._layer.get_weights():\\n size = variable_ndarray.size\\n self._dimensions.append((variable_ndarray.shape, size))\\n self._size += size\",\n \"def voxel_count(self):\\n return self.cols * self.rows * self.sections\",\n \"def get_raw_image_sizes() -> set:\\n sizes = set()\\n data = SUNRGBDTrainDataset(True, augment=False)\\n for i in range(len(data)):\\n sizes.add(data[i][0].shape)\\n return sizes\",\n \"def test_correct_image_size(location):\\n chunkloc = resave_to_chunks(root=location[\\\"dir\\\"],\\n n_imgs=10,\\n output_stem=location[\\\"stem\\\"])\\n\\n loaded = np.load(chunkloc)\\n assert len(loaded.files) > 0\\n\\n first = loaded[loaded.files[0]]\\n assert first.shape != ()\\n assert first.shape == (520, 696)\",\n \"def setup(self):\\n self.debug(\\\"Setup ..\\\")\\n\\n if self.pipeline.settings.useHardwarePCF:\\n self.error(\\n \\\"Global Illumination does not work in combination with PCF!\\\")\\n import sys\\n sys.exit(0)\\n return\\n\\n self.settings = VoxelSettingsManager()\\n self.settings.loadFromFile(join(self.sceneRoot, \\\"voxels.ini\\\"))\\n\\n self.debug(\\n \\\"Loaded voxels, grid resolution is\\\", self.settings.GridResolution)\\n\\n self.gridScale = self.settings.GridEnd - self.settings.GridStart\\n self.voxelSize = self.gridScale / float(self.settings.GridResolution)\\n self.entrySize = Vec2(\\n 1.0 / float(self.settings.StackSizeX), 1.0 / float(self.settings.StackSizeY))\\n self.frameIndex = 0\\n\\n invVoxelSize = Vec3(\\n 1.0 / self.voxelSize.x, 1.0 / self.voxelSize.y, 1.0 / self.voxelSize.z)\\n invVoxelSize.normalize()\\n self.normalizationFactor = invVoxelSize / \\\\\\n float(self.settings.GridResolution)\\n\\n # Debugging of voxels, VERY slow\\n self.debugVoxels = False\\n\\n if self.debugVoxels:\\n self.createVoxelDebugBox()\\n\\n # Load packed voxels\\n packedVoxels = Globals.loader.loadTexture(\\n join(self.sceneRoot, \\\"voxels.png\\\"))\\n packedVoxels.setFormat(Texture.FRgba8)\\n packedVoxels.setComponentType(Texture.TUnsignedByte)\\n # packedVoxels.setKeepRamImage(False)\\n\\n # Create 3D Texture to store unpacked voxels\\n self.unpackedVoxels = Texture(\\\"Unpacked voxels\\\")\\n self.unpackedVoxels.setup3dTexture(self.settings.GridResolution, self.settings.GridResolution, self.settings.GridResolution,\\n Texture.TFloat, Texture.FRgba8)\\n self.unpackedVoxels.setMinfilter(Texture.FTLinearMipmapLinear)\\n self.unpackedVoxels.setMagfilter(Texture.FTLinear)\\n\\n self.unpackVoxels = NodePath(\\\"unpackVoxels\\\")\\n self.unpackVoxels.setShader(\\n BetterShader.loadCompute(\\\"Shader/GI/UnpackVoxels.compute\\\"))\\n\\n print \\\"setting inputs ..\\\"\\n self.unpackVoxels.setShaderInput(\\\"packedVoxels\\\", packedVoxels)\\n print \\\"setting inputs ..\\\"\\n self.unpackVoxels.setShaderInput(\\n \\\"stackSizeX\\\", LVecBase3i(self.settings.StackSizeX))\\n print \\\"setting inputs ..\\\"\\n self.unpackVoxels.setShaderInput(\\n \\\"gridSize\\\", LVecBase3i(self.settings.GridResolution))\\n print \\\"setting inputs ..\\\"\\n self.unpackVoxels.setShaderInput(\\\"destination\\\", self.unpackedVoxels)\\n print \\\"executing shader ..\\\"\\n self._executeShader(\\n self.unpackVoxels, self.settings.GridResolution / 8, self.settings.GridResolution / 8, self.settings.GridResolution / 8)\\n\\n print \\\"creating direct radiance texture ..\\\"\\n # Create 3D Texture to store direct radiance\\n self.directRadianceCache = Texture(\\\"Direct radiance cache\\\")\\n self.directRadianceCache.setup3dTexture(self.settings.GridResolution, self.settings.GridResolution, self.settings.GridResolution,\\n Texture.TInt, Texture.FR32i)\\n\\n self.directRadiance = Texture(\\\"Direct radiance\\\")\\n self.directRadiance.setup3dTexture(self.settings.GridResolution, self.settings.GridResolution, self.settings.GridResolution,\\n Texture.TFloat, Texture.FRgba16)\\n\\n print \\\"setting texture states ..\\\"\\n for prepare in [self.directRadiance, self.unpackedVoxels]:\\n prepare.setMagfilter(Texture.FTLinear)\\n prepare.setMinfilter(Texture.FTLinearMipmapLinear)\\n prepare.setWrapU(Texture.WMBorderColor)\\n prepare.setWrapV(Texture.WMBorderColor)\\n prepare.setWrapW(Texture.WMBorderColor)\\n prepare.setBorderColor(Vec4(0,0,0,1))\\n\\n self.unpackedVoxels.setBorderColor(Vec4(0))\\n # self.directRadiance.setBorderColor(Vec4(0))\\n\\n self.populateVPLNode = NodePath(\\\"PopulateVPLs\\\")\\n self.clearTextureNode = NodePath(\\\"ClearTexture\\\")\\n self.copyTextureNode = NodePath(\\\"CopyTexture\\\")\\n self.generateMipmapsNode = NodePath(\\\"GenerateMipmaps\\\")\\n self.convertGridNode = NodePath(\\\"ConvertGrid\\\")\\n\\n\\n if False:\\n surroundingBox = Globals.loader.loadModel(\\n \\\"Models/CubeFix/Model.egg\\\")\\n surroundingBox.setPos(self.settings.GridStart)\\n surroundingBox.setScale(self.gridScale)\\n\\n # surroundingBox.setTwoSided(True)\\n surroundingBox.flattenStrong()\\n surroundingBox.reparentTo(Globals.render)\\n\\n self.bindTo(self.populateVPLNode, \\\"giData\\\")\\n self.reloadShader()\\n\\n self._generateMipmaps(self.unpackedVoxels)\",\n \"def _set_x_block_size(self):\\n self._scene_gen.block_dimensions = (self._block_size_x_spinbox.value(),\\n self._scene_gen.block_dimensions[Y],\\n self._scene_gen.block_dimensions[Z])\\n self._refresh_view()\",\n \"def setinputsizes(self, sizes):\\r\\n if self._closed:\\r\\n raise Error('The cursor has been closed.')\\r\\n if self.connection._closed:\\r\\n raise Error('The connection to the database has been closed.')\\r\\n else:\\r\\n pass\",\n \"def __init__(self, nb_sub_images, window_size, recovery, image_horiz_size):\\n self.nb_sub_images = nb_sub_images\\n self.window_size = window_size\\n self.recovery = recovery\\n self.image_horiz_size = image_horiz_size\",\n \"def set_image_data(self, data_file):\\n # TODO: support other file formats, like hd5 and maybe raw binary?\\n import scipy.io\\n self.image_data = np.atleast_3d(scipy.io.loadmat(data_file).values()[0])\\n if self.image_data.ndim == 3:\\n self.image_data = self.image_data.reshape(self.image_data.shape + (1,))\\n # TODO: confirm that this voxel reordering is necessary. Maybe lean on the recon\\n # folks to standardize thier voxle order? Might also look at\\n self.image_data = self.image_data.transpose((1,0,2,3))[::-1,:,::-1,:]\\n\\n if self.image_data.shape[0] != self.size_x or self.image_data.shape[1] != self.size_y:\\n msg = 'Image matrix discrepancy. Fixing the header, assuming image_data is correct...'\\n self.log and self.log.warning(msg) or print(msg)\\n self.size_x = self.image_data.shape[0]\\n self.size_y = self.image_data.shape[1]\\n self.mm_per_vox[0] = float(self.fov[0] / self.size_x)\\n self.mm_per_vox[1] = float(self.fov[1] / self.size_y)\\n if self.image_data.shape[2] != self.num_slices:\\n msg = 'Image slice count discrepancy. Fixing the header, assuming image_data is correct...'\\n self.log and self.log.warning(msg) or print(msg)\\n self.num_slices = self.image_data.shape[2]\\n if self.image_data.shape[3] != self.num_timepoints:\\n msg = 'Image time frame discrepancy (header=%d, array=%d). Fixing the header, assuming image_data is correct...' % (self.num_timepoints, self.image_data.shape[3])\\n self.log and self.log.warning(msg) or print(msg)\\n self.num_timepoints = self.image_data.shape[3]\",\n \"def set_default_parameters(self):\\n super().set_default_parameters()\\n if not \\\"region_size\\\" in vars(self):\\n self.region_size = 0.08\\n if not \\\"RGB_bands\\\" in vars(self):\\n self.RGB_bands = [\\\"B4\\\",\\\"B3\\\",\\\"B2\\\"]\\n if not \\\"split_RGB_images\\\" in vars(self):\\n self.split_RGB_images = True\\n # in PROCESSED dir we expect RGB. NDVI, BWNDVI\\n self.num_files_per_point = 3\",\n \"def countDataSize(self,filename):\\n \\n d = h5py.File(filename,'r')\\n features = d['spectrometer/features'][:]\\n select = self.selectData(features.astype(float), self.ifeature, d)\\n N = len(features[select])\\n d.close()\\n\\n N = (N//self.offsetLen) * self.offsetLen\\n\\n N = N*self.Nfeeds\\n\\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\\n self.datasizes += [int(N/self.Nfeeds)]\\n self.Nsamples += int(N)\",\n \"def countDataSize(self,filename):\\n \\n try:\\n d = h5py.File(filename,'r')\\n except:\\n print(filename)\\n return \\n\\n N = 0\\n scan_edges = d['level2/Statistics/scan_edges'][:]\\n for (start,end) in scan_edges:\\n N += (end-start)//self.offsetLen * self.offsetLen\\n d.close()\\n\\n N = N*self.Nfeeds\\n\\n self.chunks += [[int(self.Nsamples), int(self.Nsamples+N)]]\\n self.datasizes += [int(N/self.Nfeeds)]\\n self.Nsamples += int(N)\",\n \"def get_num_of_images(self):\",\n \"def _set_pixel_size(self) -> None:\\n # Not Pansharpened images\\n if self.band_combi == Sv1BandCombination.PMS:\\n # TODO: manage default resolution for PAN band ?\\n self.pixel_size = self._ms_res\\n # Pansharpened images\\n else:\\n self.pixel_size = self._pan_res\",\n \"def resize(self, **kwargs):\\n\\n if self.image is None:\\n raise ValueError('self.image is None! The image has to be initialized!')\\n\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n self.image = ndimage.interpolation.zoom(self.image * 1., **kwargs)\\n\\n # if size <= 3, pad with zeros\\n\\n if np.min(self.image.shape) < 5:\\n self.image = np.pad(self.image, pad_width=3, mode='constant', constant_values=0)\\n\\n if self.image.max() > 0:\\n self.image = rescale_intensity(self.image, out_range=(0, 255))\\n\\n if 'Voxel size x' in self.metadata.index and 'Voxel size y' in self.metadata.index \\\\\\n and 'Voxel size z' in self.metadata.index:\\n new_voxel_size = np.array([self.metadata['Voxel size z'], self.metadata['Voxel size y'],\\n self.metadata['Voxel size x']]) / kwargs['zoom']\\n self.metadata['Voxel size'] = str(new_voxel_size)\\n self.metadata['Voxel size z'], self.metadata['Voxel size y'], self.metadata['Voxel size x'] = new_voxel_size\\n\\n return self.image\",\n \"def set_pic_size(self, im_name):\\n im_vals = np.genfromtxt(im_name, delimiter=self.delim)\\n self.pic_width = int(np.size(im_vals[0]) - 1) # the first column of ASCII image is row number\\n try: self.pic_height = int(np.size(im_vals[:,0])) \\n except IndexError: \\n self.pic_width = int(np.size(im_vals) - 1)\\n self.pic_height = 1\\n self.create_rect_mask()\\n return self.pic_width, self.pic_height\",\n \"def setFilmSize(self, size_x, size_y):\\n self.lens.setFilmSize(size_x, size_y)\\n self.rebuildMatrixCache()\",\n \"def set_size(self, w, h):\\n\\t\\tpass\",\n \"def set_size(self, width, height):\\r\\n \\r\\n self.image = pygame.transform.scale(self.image, (width, height))\\r\\n self.rect = self.image.get_rect()\",\n \"def setImageSize(cls, width, height):\\n\\t\\tcls._width = width\\n\\t\\tcls._height = height\",\n \"def dimensions():\",\n \"def chunksize(self, value):\\n\\n self.data.chunksize = int(value)\\n self.mask.chunksize = int(value)\",\n \"def __init__(self, image_size, heatmap_size):\\n super(ProjectLayer, self).__init__()\\n self.image_size = image_size\\n self.heatmap_size = heatmap_size\\n if isinstance(self.image_size, int):\\n self.image_size = [self.image_size, self.image_size]\\n if isinstance(self.heatmap_size, int):\\n self.heatmap_size = [self.heatmap_size, self.heatmap_size]\",\n \"def updateSize(self, *args):\\n width = self.width.get()\\n height = self.height.get()\\n self.initialXScale.config(to=width)\\n self.initialYScale.config(to=height)\\n # error check that state is not outside bounds\\n for ball, state in self.ballStates.items():\\n if state[0] > width:\\n state[0] = width\\n if state[1] > height:\\n state[1] = height\",\n \"def sizes(options):\\n # import data\\n pixels = dict() # volumes are given in #pixels\\n snap_mask = \\\"/net/astrogate/export/astrodata/jgacon/filex/processing/\\\" \\\\\\n \\\"export/f8_h50_v100_objs_snap_%d.csv\\\"\\n snap_ids = np.arange(2,28+1)\\n z = snapid2z(snap_ids)\\n print z\\n\\n for id in snap_ids:\\n snap = snap_mask % (id - 1) # fix: snap number one too low in filename\\n pixels[id] = np.genfromtxt(snap)[1:-1,1] # row 2 contains volumes\\n # rm void & halo volumes\\n\\n # visualise\\n if \\\"err\\\" in options.keys():\\n nums = np.array([pixels[id].size for id in snap_ids])\\n avgs = np.array([np.mean(pixels[id]) for id in snap_ids])\\n mods = np.array([st.mode(pixels[id])[0][0] for id in snap_ids])\\n meds = np.array([np.median(pixels[id]) for id in snap_ids])\\n stds = np.array([np.std(pixels[id]) for id in snap_ids])\\n\\n print mods\\n print mods.shape\\n\\n plt.figure()\\n plt.title(\\\"Sizes of filaments as function of redshift\\\")\\n plt.xlabel(\\\"Redshift $z$\\\")\\n plt.xticks(snap_ids[::3], z[::3])\\n\\n plt.ylabel(\\\"Size in #pixels\\\")\\n\\n plt.errorbar(snap_ids, avgs, yerr=stds, label=\\\"Mean\\\")\\n plt.plot(snap_ids, mods, \\\"g\\\", label=\\\"Mode\\\")\\n plt.plot(snap_ids, meds, \\\"c\\\", label=\\\"Median\\\")\\n plt.legend(loc=\\\"best\\\")\\n\\n plt.twinx()\\n plt.ylabel(\\\"#Filaments\\\", color=\\\"r\\\")\\n plt.tick_params(\\\"y\\\", colors=\\\"r\\\")\\n\\n plt.plot(snap_ids, nums, \\\"r--\\\")\\n\\n plt.savefig(options[\\\"err\\\"])\\n\\n if \\\"dist\\\" in options.keys():\\n targets = np.array([5,10,15,20,25])\\n plt.figure()\\n plt.title(\\\"Volume distribution of filaments\\\")\\n plt.xlabel(\\\"Volume $V$ in #pixels\\\")\\n plt.ylabel(\\\"#Element with $V$ / Total #Elements\\\")\\n plt.xlim([0,1000])\\n for target in targets:\\n sns.kdeplot(pixels[target], label=\\\"$z$ = %f\\\" % snapid2z(target))\\n plt.legend(loc=\\\"best\\\")\\n plt.savefig(options[\\\"dist\\\"])\\n\\n if \\\"dist_inter\\\" in options.keys():\\n default = snap_ids[-1]\\n fig, ax = plt.subplots()\\n plt.subplots_adjust(bottom=0.25)\\n sns.kdeplot(pixels[int(default - 2)], ax=ax)\\n plt.xlim([0, 1000])\\n plt.ylim([0, 0.01])\\n plt.xlabel(\\\"Volume $V$ of filaments in #pixels\\\")\\n plt.ylabel(\\\"#Filaments with volume $V$ / Total #Filaments\\\")\\n\\n nums = np.array([pixels[id].size for id in snap_ids])\\n ax2 = ax.twinx()\\n ax2.set_ylabel(\\\"#Filaments\\\", color=\\\"r\\\", alpha=0.5)\\n ax2.tick_params(axis=\\\"y\\\", labelcolor=\\\"r\\\")\\n ax2_x = np.linspace(0, 1000, nums.size)\\n ax2.plot(ax2_x, nums, \\\"r--\\\", alpha=0.5)\\n point, = ax2.plot(ax2_x[default - 2], nums[default - 2], \\\"ro\\\", alpha=0.5)\\n\\n axcolor = 'lightgoldenrodyellow'\\n axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)\\n sid = Slider(axfreq, \\\"ID\\\", 2, 28, valinit=default, valstep=1)\\n ax.set_title(\\\"$z$ = %f\\\" % snapid2z(default))\\n\\n def update(val):\\n id = sid.val\\n\\n print id\\n #ax.clear()\\n ax.set_ydata()\\n ax.set_xdata()\\n ax.set_title(\\\"$z$ = %f\\\" % snapid2z(int(id)))\\n ax.set_xlim([0,1000])\\n ax.set_ylim([0, 0.01])\\n sns.kdeplot(pixels[int(id)], ax=ax)\\n point.set_xdata(ax2_x[int(id) - 2])\\n point.set_ydata(nums[int(id) - 2])\\n fig.canvas.draw_idle()\\n sid.on_changed(update)\\n\\n plt.show()\\n\\n\\n if \\\"hist\\\" in options.keys():\\n conc = None\\n for id, vols in pixels.iteritems():\\n data = np.empty((vols.size, 2))\\n data[:,0] = id\\n data[:,1] = vols\\n\\n if conc is None:\\n conc = data\\n else:\\n conc = np.vstack((conc, data))\\n\\n plt.figure()\\n plt.hist2d(conc[:,0], conc[:,1], bins=(snap_ids.size, 1000))\\n plt.ylim([100,400])\\n plt.savefig(options[\\\"hist\\\"])\",\n \"def SetSize(self, m: 'unsigned int', n: 'unsigned int') -> \\\"void\\\":\\n return _itkArray2DPython.itkArray2DD_SetSize(self, m, n)\",\n \"def get_image_size(self):\",\n \"def apply(self):\\n self.grid_size = self.values[0]\",\n \"def _resize(self, size: Tuple[int, int], axis: int = None) -> None:\\n\\t\\tif self.name == \\\"\\\":\\n\\t\\t\\tself.ds._file['/matrix'].resize(size, axis)\\n\\t\\telse:\\n\\t\\t\\tself.ds._file['/layers/' + self.name].resize(size, axis)\",\n \"def GetVoxelSize(vDataSet):\\r\\n nx = vDataSet.GetSizeX()\\r\\n ny = vDataSet.GetSizeY()\\r\\n nz = vDataSet.GetSizeZ()\\r\\n\\r\\n if nx > 0: nx = abs(vDataSet.GetExtendMaxX()-vDataSet.GetExtendMinX())/nx;\\r\\n if ny > 0: ny = abs(vDataSet.GetExtendMaxY()-vDataSet.GetExtendMinY())/ny;\\r\\n if nz > 0: nz = abs(vDataSet.GetExtendMaxZ()-vDataSet.GetExtendMinZ())/nz;\\r\\n\\r\\n return nx,ny,nz\",\n \"def _get_box_sizes(self, image_info, cat):\\n\\n\\n file_id=0\\n impath=image_info['image_path'][file_id].strip()\\n ext=image_info['image_ext'][file_id]\\n wcs_data = fitsio.read_header(impath, ext=ext)\\n wcs = eu.wcsutil.WCS(wcs_data)\\n\\n\\n jacob = wcs.get_jacobian(100,100)\\n dudcol, dudrow, dvdcol, dvdrow = jacob\\n\\n det = dvdrow*dudcol - dvdcol*dudrow\\n pixel_scale = np.sqrt(abs(det))\\n print('found pixel scale:',pixel_scale)\\n box_size = cat['box_size_arcsec']/pixel_scale\\n\\n # clip to range\\n box_size.clip(\\n min=self['min_box_size'],\\n max=self['max_box_size'],\\n out=box_size,\\n )\\n box_size = box_size.astype('i4')\\n\\n w,=np.where( ( (box_size % 2) != 0 ) )\\n if w.size > 0:\\n box_size[w] += 1\\n\\n return box_size\",\n \"def __init__(self, sizes, image_size):\\n super(CraterNetwork, self).__init__(sizes);\\n self.im_size = image_size\\n self.validating = False\",\n \"def SetSize(self, m: 'unsigned int', n: 'unsigned int') -> \\\"void\\\":\\n return _itkArray2DPython.itkArray2DUI_SetSize(self, m, n)\",\n \"def onSetToFourthSize(self, evt):\\n\\t\\tself.halfResampleZ.Enable(0)\\n\\t\\tself.fourthResampleZ.Enable(1)\\n\\t\\tif self.dataUnits:\\n\\t\\t\\tzf = 1\\n\\t\\t\\tx, y, z = self.dataUnits[0].dataSource.getOriginalDimensions()\\n\\t\\t\\t\\n\\t\\t\\tif self.fourthResampleZ.GetValue():\\n\\t\\t\\t\\tzf = 0.25\\n\\t\\t\\tself.currSize = int(0.25 * x), int(0.25 * y), int(zf * z) \\n\\t\\tfor obj in [self.factorLabel, self.dimLabel, self.newDimX, self.newDimY, self.newDimZ, self.factorX, self.factorY, self.factorZ]:\\n\\t\\t\\tobj.Enable(0)\",\n \"def scan_size(self):\\n max_memory = 10e9/4 # because 32-bit floats will be used\\n memory = 0\\n for f in self.filenames:\\n img = cv2.imread(f, int(self.color))\\n if img is not None:\\n m = 1\\n for dim in img.shape:\\n m *= dim\\n memory += m\\n else:\\n print('error opening %s' % f)\\n print('size is %s bytes' % memory)\\n return memory <= max_memory\",\n \"def scan_size(self):\\n max_memory = 10e9/4 # because 32-bit floats will be used\\n memory = 0\\n for f in self.filenames:\\n img = cv2.imread(f, int(self.color))\\n if img is not None:\\n m = 1\\n for dim in img.shape:\\n m *= dim\\n memory += m\\n else:\\n print('error opening %s' % f)\\n print('size is %s bytes' % memory)\\n return memory <= max_memory\",\n \"def scan_size(self):\\n max_memory = 10e9/4 # because 32-bit floats will be used\\n memory = 0\\n for f in self.filenames:\\n img = cv2.imread(f, int(self.color))\\n if img is not None:\\n m = 1\\n for dim in img.shape:\\n m *= dim\\n memory += m\\n else:\\n print('error opening %s' % f)\\n print('size is %s bytes' % memory)\\n return memory <= max_memory\",\n \"def getDimensions():\",\n \"def SetSize(self, m: 'unsigned int', n: 'unsigned int') -> \\\"void\\\":\\n return _itkArray2DPython.itkArray2DF_SetSize(self, m, n)\",\n \"def get_image_sizes():\\n widths = []\\n heights = []\\n\\n from settings import folders_location\\n for individual_folder_name in listdir(folders_location):\\n individual_training_folder_path = folders_location + individual_folder_name + \\\"/training/\\\"\\n\\n image_paths = listdir(individual_training_folder_path)\\n for image_path in image_paths:\\n img = cv2.imread(individual_training_folder_path + image_path)\\n\\n height, width, channel = img.shape\\n widths.append(width)\\n heights.append(height)\\n\\n print(individual_training_folder_path + image_path)\\n\\n print(\\\"Min: %s, Max: %s\\\" % (np.min(widths), np.max(widths)))\\n print(\\\"Average: %s\\\" % (np.average(widths)))\\n\\n return widths\",\n \"def set_data_size(self, num_bytes):\\n self.model.data_size = num_bytes\\n self.refresh_memory()\",\n \"def set_variables(self):\\n self.feat_size = None # Set this in your inherited class\\n raise NotImplementedError(\\\"set_variables() is not implemented\\\")\",\n \"def set_element_dimensions(self, size_x, size_y, size_z):\\n size_x = 1.0 * size_x\\n size_y = 1.0 * size_y\\n size_z = 1.0 * size_z\\n x = np.repeat(size_x, self.numelements)\\n y = np.repeat(size_y, self.numelements)\\n z = np.repeat(size_z, self.numelements)\\n self.dimensions = g.Points.from_xyz(x, y, z)\\n return self\",\n \"def estimate_size(self, datasets):\\n datasets = Datasets(datasets)\\n \\n# self.fit.run(datasets)\\n\\n if self.size_values:\\n self.size_parameter.scan_values = self.size_values.to_value(self.size_parameter.unit)\\n self.size_parameter.scan_min = self.size_min.to_value(self.size_parameter.unit)\\n self.size_parameter.scan_max = self.size_max.to_value(self.size_parameter.unit)\\n self.size_parameter.scan_n_values = self.size_n_values\\n \\n result = super().run(datasets, self.size_parameter)\\n return result\",\n \"def __len__(self):\\n return self._num_samples_per_file * len(self._files) // self._world_size\",\n \"def resize_images(self, images):\\n \\n img_list = []\\n \\n for img in images:\\n \\n yield np.resize(img, (64, 64, 3))\",\n \"def SetImageSize(self,x=IS.GET_IMAGE_SIZE_X_MAX,y=0):#non-zero ret\\r\\n r = CALL(\\\"SetImageSize\\\",self,INT(x),INT(y))\\r\\n if x & 0x8000 == 0x8000:\\r\\n return self.CheckForNoSuccessError(r)\\r\\n return self.CheckForSuccessError(r)\",\n \"def __init__(self, pool_size):\\n self.pool_size = pool_size\\n if self.pool_size > 0: # create an empty pool\\n self.num_imgs = 0\\n self.images = []\",\n \"def _get_image_size(self):\\n return (3, 224, 224)\",\n \"def GetTextureDimensions(self):\\n ...\",\n \"def set_size(self, size):\\n \\n self.width = size[0]\\n self.height = size[1]\",\n \"def set_size(self, mode):\\n return len(self.data_index[mode])\",\n \"def set_point_size(self, point_size=0.0):\\r\\n for b in self.buf:\\r\\n b.unib[8] = point_size\",\n \"def load(self):\\n\\n # get files in folder\\n files = [f for f in listdir(self.data_path)]\\n print(\\\"loading images from folder: %s\\\" % self.data_path)\\n\\n images = []\\n image_targets = []\\n for f in files:\\n filepath = path.join(self.data_path, f)\\n images.append(io.imread(filepath, as_grey=True))\\n image_targets.append(self.target)\\n\\n # define new size and resize images\\n new_size = (2 ** self.size_exponent, 2 ** self.size_exponent)\\n for i in range(0, len(images)):\\n # images[i] = transform.resize(images[i], new_size)\\n images[i] = misc.imresize(images[i], new_size) / 16\\n\\n self.images = images\\n self.targets = image_targets\",\n \"def initial_resizing(fr_raw_data_path, fr_data_path, dim=300):\\n with h5py.File(fr_raw_data_path, 'r') as data:\\n images = resize_array(np.asarray(data['images'].value), dim=dim)\\n labels = data['labels'].value\\n \\n with h5py.File(fr_data_path, 'w') as f:\\n f.create_dataset('images', data=images)\\n\\n with h5py.File(fr_raw_data_path, 'r') as data: \\n f.copy(data['fri_data'], 'fri_data')\\n f.copy(data['frii_data'], 'frii_data')\\n f.copy(data['labels'], 'labels')\",\n \"def size(self, val):\\n self.width = val\\n self.height = val\",\n \"def resize(self):\\n pass\",\n \"def __init__(self, size=(2, 2), **kwargs):\\n super(MaxUnpooling2D, self).__init__(**kwargs)\\n self.size = size\",\n \"def __len__(self):\\n return self.num_images\",\n \"def __len__(self):\\n return self.num_images\",\n \"def __len__(self):\\n return self.num_images\",\n \"def __len__(self):\\n return self.num_images\",\n \"def __len__(self):\\n return self.num_images\",\n \"def set_num_images(self,num_images):\\n if num_images != self.num_images:\\n self.counts = [{} for _ in range(num_images)]\\n\\n for _ in range(num_images,len(self.thresholds)): # delete unneeded thresholds\\n self.thresholds.pop()\\n for _ in range(len(self.thresholds), num_images): # make new thresholds\\n self.thresholds.append(self.default_threshold)\\n\\n for _ in range(num_images,len(self.autothreshs)): # delete unneeded autothreshs\\n self.autothreshs.pop()\\n for _ in range(len(self.autothreshs), num_images): # make new autothreshs\\n self.autothreshs.append(self.default_autothresh)\\n\\n self.num_images = num_images\",\n \"def get_voxel_size(path: str) -> float:\\n dcm = pydicom.dcmread(path, force=True)\\n x_str, y_str = dcm.PixelSpacing\\n x = Decimal(str(x_str))\\n y = Decimal(str(y_str))\\n z = Decimal(str(dcm.SpacingBetweenSlices))\\n print(float(x * y * z))\\n return float(x * y * z)\",\n \"def setUp(self):\\n self.gray_image = np.ndarray((100, 200), dtype=np.uint8)\\n self.rgb_image = np.ndarray((100, 200, 3), dtype=np.uint8)\",\n \"def scale(self, size=128):\\n scale_factor = size / max(self.voxels.shape)\\n self.voxels = ndimage.zoom(self.voxels, scale_factor)\\n self.point_position = self.point_position * scale_factor\\n self.voxel_size = False # To ignore this\\n \\n return(self)\",\n \"def setImages( self, event_key, images ):\\n print \\\"event index\\\",event_key[0]\\n self.run = event_key[1]\\n self.subrun = event_key[2]\\n self.event_num = event_key[3]\\n print self.run,self.subrun,self.event_num\\n self.images = images\\n #print self.images.img_v\\n #for img in self.images.img_v:\\n # print img.shape\\n self.labeltools.setImage( event_key[0], self.images )\",\n \"def _set_x_size(self):\\n self._level_gen.size = (self._level_size_x_spinbox.value(),\\n self._level_gen.size[Y],\\n self._level_gen.size[Z])\\n self._refresh_view()\",\n \"def __CalculateSliceSize(self, readShapeZYX):\\n # readShapeZYX is the dimension of the data we must READ to fill the required output area;\\n # i.e .the fill area plus margins. If we're filling globally it's the same thing.\\n dataBPP = 4\\n memLimit = self._jobDetails.MemTargetBytes\\n outputsBPP = dataBPP * 2 + 1 # the output data, distances, and flags\\n # approximate total number of pixels we can read for each file\\n sliceSqrd = memLimit / (readShapeZYX[0] * (dataBPP + outputsBPP))\\n # not implementing slicing in y dimension so xSize is total pixels / total height\\n sliceXSize = sliceSqrd / readShapeZYX[1]\\n return sliceXSize\",\n \"def updateSize(self, *args):\\n return None\",\n \"def onSize(self, event): \\n\\t\\tw, h = self.GetClientSizeTuple()\\n\\t\\tself.tree.SetDimensions(0, 0, w, h)\",\n \"def set_dimensions(self, fshape=1, params=np.array([0., 0., 0., 0.])):\\n self.FHIT_C = 1\\n self.FSHAPE = fshape\\n self.RLEN1 = params[0]\\n self.RLEN2 = params[1]\\n self.RWIDX1 = params[2]\\n self.RWIDX2 = params[3]\",\n \"def test_full_resize(self):\\n number_of_pixels = 300\\n destination = base_path +'/test_data/rendering_tests/resized_images/'\\n source_folder = base_path + '/test_data/rendering_tests/filter_database/'\\n\\n\\n for the_file in os.listdir(destination):\\n file_path = os.path.join(destination, the_file)\\n if os.path.isfile(file_path):\\n os.unlink(file_path)\\n\\n\\n self.assertEqual(0, len(os.listdir(destination)))\\n rb.find_all_files(number_of_pixels,source_folder, destination)\\n self.assertEqual(6, len(os.listdir(destination)))\\n for the_file in os.listdir(destination):\\n file_path = os.path.join(destination,the_file)\\n with Image.open(file_path) as f:\\n self.assertNotEqual(number_of_pixels+5, f.size[0])\\n self.assertNotEqual(number_of_pixels+5, f.size[1])\\n # the above checks that the size does not vary as needed\\n # probably not necessary\\n self.assertEqual(number_of_pixels, f.size[0])\\n self.assertEqual(number_of_pixels, f.size[1])\",\n \"def size(img):\\n\\treturn img.size\",\n \"def _set_z_block_size(self):\\n self._scene_gen.block_dimensions = (self._scene_gen.block_dimensions[X],\\n self._scene_gen.block_dimensions[Y],\\n self._block_size_z_spinbox.value())\\n self._refresh_view()\",\n \"def update_resize(self, viewer, dims):\\n self.recalc(viewer)\",\n \"def setSurfaceSize(xmin, xmax, ymin, ymax):\\n dislin.sursze(xmin, xmax, ymin, ymax)\",\n \"def set_pool_size(self, pool_size):\\n self._semantic_decoder.set_pool_size(pool_size)\\n if self._instance_decoder is not None:\\n self._instance_decoder.set_pool_size(pool_size)\",\n \"def __init__(self, images, batch_size, ctx, multisp):\\n self.ctx = ctx\\n self.batch_size = batch_size\\n self.images = []\\n self.multisp = multisp\\n\\n self.images=images\\n\\n if self.images:\\n self.channels, self.imgsize, _ = self._read_img(self.images[0]['data']).shape\\n\\n logging.info(\\\"Found a total of {} images\\\".format(len(self.images)))\",\n \"def input_load(self):\\n return self.nmos_size + self.pmos_size\",\n \"def estimate_size(self, ixreader):\\r\\n raise NotImplementedError\",\n \"def SetDimensions(self, p_int, p_int_1, p_int_2, p_int_3, p_int_4, p_int_5, p_int_6):\\n ...\",\n \"def setsize(self, size):\\n self.__size = size\",\n \"def testSize (self):\\r\\n \\r\\n perpixel = bytes_per_pixel [self.bih_vals [bih_BitCount]]\\r\\n width = self.bih_vals [bih_Width]\\r\\n height = self.bih_vals [bih_Height]\\r\\n expected = self.bih_vals [bih_SizeImage]\\r\\n\\r\\n # Rows always have multiples of 4 bytes\\r\\n \\r\\n padding = 3 - ((perpixel * width + 3) % 4)\\r\\n size = (width * perpixel + padding) * height\\r\\n\\r\\n if not size == expected:\\r\\n print \\\"Calculated size = %d (<> %d)\\\" % (size, expected)\\r\\n print \\\"***** File size error *****\\\"\",\n \"def __len__(self):\\n return math.ceil(self.number_of_images / self.batch_size)\",\n \"def input_image_size(interpreter):\\n _, height, width, channels = interpreter.get_input_details()[0]['shape']\\n return width, height, channels\",\n \"def __init__(self, *, points, n_x=1, n_y=1, n_z=1, size_x=None, size_y=None, size_z=None, range=None, **kwargs):\\n super().__init__(points=points, **kwargs)\\n\\n if size_x is None or size_y is None or size_z is None:\\n print('WARNING: when computing a voxelgrid for running a Neural net, voxel sizes should be homogeneous among different point clouds or the neural network wont learn spatial relationships. To ensure this, use (size_x, size_y, size_z) instead of (n_x, n_y, n_z)')\\n\\n self.x_y_z = [n_x, n_y, n_z]\\n self.sizes = np.array([size_x, size_y, size_z])\\n\\n if range is None:\\n self.xyzmin = self.bounds[0]\\n self.xyzmax = self.bounds[1]\\n else: \\n self.xyzmin = range[:3]\\n self.xyzmax = range[3:]\\n\\n for n, size in enumerate(self.sizes):\\n if size is None:\\n continue\\n\\n # ensure that 'sizes' are respected by making the box bigger if necessary\\n margin = size - ((self.xyzmax[n] - self.xyzmin[n]) % size)\\n self.xyzmin[n] -= margin / 2\\n self.xyzmax[n] += margin / 2\\n self.x_y_z[n] = int(round((self.xyzmax[n] - self.xyzmin[n]) / size))\",\n \"def setTestSampleSize(self, Ntest):\\n self.Ntest = Ntest\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66988456","0.6689091","0.6536548","0.61790437","0.6176843","0.61598647","0.6149251","0.6120889","0.6050634","0.6040322","0.60017174","0.59967524","0.59520566","0.5908052","0.58848417","0.5881362","0.5838115","0.5830686","0.5829773","0.57882386","0.57879984","0.57736975","0.57540166","0.57257664","0.5723163","0.5719538","0.57143813","0.5660189","0.5649517","0.5646133","0.56358474","0.5603753","0.55859613","0.5564792","0.5561999","0.5553092","0.5542233","0.55421203","0.5539714","0.55349207","0.55238724","0.5517819","0.54927963","0.54754645","0.54752177","0.5474271","0.5474271","0.5474271","0.5471876","0.54173285","0.5406461","0.5404069","0.5393685","0.53915197","0.5371111","0.53633344","0.53435415","0.5337368","0.53284353","0.53269225","0.53251433","0.53226656","0.53136903","0.5310848","0.53105265","0.5307229","0.530705","0.5301535","0.5296068","0.52944183","0.52944183","0.52944183","0.52944183","0.52944183","0.5290509","0.52859247","0.52769566","0.5270676","0.52693075","0.5267989","0.5264675","0.52631307","0.5257604","0.52524304","0.52492684","0.5238744","0.5238017","0.52356434","0.5227367","0.52178025","0.5206543","0.52036506","0.5199872","0.51828796","0.5172366","0.51670367","0.5166318","0.516528","0.5163989","0.5162968"],"string":"[\n \"0.66988456\",\n \"0.6689091\",\n \"0.6536548\",\n \"0.61790437\",\n \"0.6176843\",\n \"0.61598647\",\n \"0.6149251\",\n \"0.6120889\",\n \"0.6050634\",\n \"0.6040322\",\n \"0.60017174\",\n \"0.59967524\",\n \"0.59520566\",\n \"0.5908052\",\n \"0.58848417\",\n \"0.5881362\",\n \"0.5838115\",\n \"0.5830686\",\n \"0.5829773\",\n \"0.57882386\",\n \"0.57879984\",\n \"0.57736975\",\n \"0.57540166\",\n \"0.57257664\",\n \"0.5723163\",\n \"0.5719538\",\n \"0.57143813\",\n \"0.5660189\",\n \"0.5649517\",\n \"0.5646133\",\n \"0.56358474\",\n \"0.5603753\",\n \"0.55859613\",\n \"0.5564792\",\n \"0.5561999\",\n \"0.5553092\",\n \"0.5542233\",\n \"0.55421203\",\n \"0.5539714\",\n \"0.55349207\",\n \"0.55238724\",\n \"0.5517819\",\n \"0.54927963\",\n \"0.54754645\",\n \"0.54752177\",\n \"0.5474271\",\n \"0.5474271\",\n \"0.5474271\",\n \"0.5471876\",\n \"0.54173285\",\n \"0.5406461\",\n \"0.5404069\",\n \"0.5393685\",\n \"0.53915197\",\n \"0.5371111\",\n \"0.53633344\",\n \"0.53435415\",\n \"0.5337368\",\n \"0.53284353\",\n \"0.53269225\",\n \"0.53251433\",\n \"0.53226656\",\n \"0.53136903\",\n \"0.5310848\",\n \"0.53105265\",\n \"0.5307229\",\n \"0.530705\",\n \"0.5301535\",\n \"0.5296068\",\n \"0.52944183\",\n \"0.52944183\",\n \"0.52944183\",\n \"0.52944183\",\n \"0.52944183\",\n \"0.5290509\",\n \"0.52859247\",\n \"0.52769566\",\n \"0.5270676\",\n \"0.52693075\",\n \"0.5267989\",\n \"0.5264675\",\n \"0.52631307\",\n \"0.5257604\",\n \"0.52524304\",\n \"0.52492684\",\n \"0.5238744\",\n \"0.5238017\",\n \"0.52356434\",\n \"0.5227367\",\n \"0.52178025\",\n \"0.5206543\",\n \"0.52036506\",\n \"0.5199872\",\n \"0.51828796\",\n \"0.5172366\",\n \"0.51670367\",\n \"0.5166318\",\n \"0.516528\",\n \"0.5163989\",\n \"0.5162968\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7176527"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":94996,"cells":{"query":{"kind":"string","value":"Loads the specified .oif file and imports data from it."},"document":{"kind":"string","value":"def loadFromFile(self, filename):\n\t\treturn []"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def load_data(self) -> None:","def _load(self):\n op_type_file_path = os.path.join(\n self._profiling_dir,\n self._csv_file_to_analyse.format(self._device_id)\n )\n op_type_file_path = validate_and_normalize_path(\n op_type_file_path, raise_key=\"Invalid op_type_file_path\")\n if not os.path.isfile(op_type_file_path):\n log.warning('The file <%s> does not exist.', op_type_file_path)\n return\n\n with open(op_type_file_path, 'r') as file:\n csv_reader = csv.reader(file)\n _ = next(csv_reader)\n for info in csv_reader:\n self._data.append(self._convert_field_type(info))","def init_from_file(self):\n self.src.load('start.00') \n self.oe1.load('start.01')\n #self.det.load('start.02')\n print('NOTE: variables loaded from start.00/start.01 files')","def load_data(self):","def load_data(self):\n self.tif_file = self._find_tif_file()\n if self.with_labeling is not None:\n self.colabel_file = self._find_colabeled_file()\n self.colabel_stack = self._load_colabeled_img()\n self.dff, self.indices = self._populate_dff_data()\n self.loaded = True","def load(self, filename):\n pass","def load(cls, from_file):\n raise NotImplementedError","def load_file(path, data_type=None, *args, **kwargs):\n\n path = os.path.normpath(path)\n if os.path.isdir(path) and path[-1] != os.sep:\n path = path + os.sep\n\n if data_type == None:\n data_type = autodetect(path)\n\n if data_type == \"prospa\":\n return dnpIO.prospa.import_prospa(path, *args, **kwargs)\n\n elif data_type == \"topspin\":\n return dnpIO.topspin.import_topspin(path, *args, **kwargs)\n\n elif data_type == \"topspin dir\":\n return dnpIO.topspin.import_topspin_dir(path, *args, **kwargs)\n\n elif data_type == \"delta\":\n return dnpIO.delta.import_delta(path, *args, **kwargs)\n\n elif data_type == \"vnmrj\":\n return dnpIO.vnmrj.import_vnmrj(path, *args, **kwargs)\n\n elif data_type == \"tnmr\":\n return dnpIO.tnmr.import_tnmr(path, *args, **kwargs)\n\n elif data_type == \"specman\":\n return dnpIO.specman.import_specman(path, *args, **kwargs)\n\n elif data_type == \"xepr\" or data_type == \"xenon\":\n return dnpIO.bes3t.import_bes3t(path, *args, **kwargs)\n\n elif data_type == \"winepr\" or data_type == \"esp\":\n return dnpIO.winepr.import_winepr(path, *args, **kwargs)\n\n elif data_type == \"h5\":\n return dnpIO.h5.load_h5(path, *args, **kwargs)\n\n elif data_type == \"power\":\n return dnpIO.power.importPower(path, *args, **kwargs)\n\n elif data_type == \"vna\":\n return dnpIO.vna.import_vna(path, *args, **kwargs)\n\n elif data_type == \"cnsi_powers\":\n return dnpIO.cnsi.get_powers(path, *args, **kwargs)\n\n else:\n raise ValueError(\"Invalid data type: %s\" % data_type)","def load(f: Union[str, os.PathLike], model):\n from ..utils.flopy_io import multi_line_strip\n\n pkg_ws = os.path.split(f)[0]\n with open(f) as foo:\n t = [0]\n while t[0] != \"ncells\":\n t = multi_line_strip(foo).split()\n\n ncells = int(t[1])\n\n t = [0]\n while t[0] != \"izone\":\n t = multi_line_strip(foo).split()\n\n method = multi_line_strip(foo).split()[0]\n\n if method in (\"internal\", \"open/close\"):\n izone = np.zeros((ncells,), dtype=int)\n i = 0\n fobj = foo\n if method == \"open/close\":\n fobj = open(os.path.join(pkg_ws, t[1]))\n while i < ncells:\n t = multi_line_strip(fobj)\n if t[0] == \"open/close\":\n if fobj != foo:\n fobj.close()\n fobj = open(os.path.join(pkg_ws, t[1]))\n for zn in t:\n izone[i] = zn\n i += 1\n else:\n izone = np.array([t[1]] * ncells, dtype=int)\n\n zon = ZoneFile6(model, izone)\n return zon","def load(self, file_id):\n pass","def load(self):\r\n self.read(self.filename)","def _load_data() -> UpliftData:\n with project_dir(\"axinova\"):\n data = UpliftData(\n ax_data=load_bin(\"ax_data.feather\"),\n ax_var_struct=load_bin(\"ax_var_struct.feather\"),\n population_codes=load_pickle(\"population_ratios.pkl\"),\n global_codes=load_pickle(\"global_code_ratios.pkl\"),\n station_codes=load_pickle(\"station_code_ratios.pkl\"),\n spr_data=load_pickle(\"spr_data.pkl\"),\n )\n data.all_stations = data.ax_data[\"Station\"].cat.categories.to_list()\n data.all_weekdays = data.ax_data[\"DayOfWeek\"].cat.categories.to_list()\n data.all_timescales = [\"Time\", \"ShortTime\", \"Hour\", \"TimeSlot\"]\n data.var_info = {}\n for (var_id, struct) in data.ax_var_struct.groupby(\"Variable\"):\n data.var_info[var_id] = dict(\n Label=struct[\"Variable_Label\"].max(),\n Codes=struct[\"Label\"].to_list(),\n Order=list(range(len(struct[\"Label_Nr\"].to_list()))),\n )\n data.combi_var = {\n \"md_SexAgeEk\": (\n data.variable_table(\"md_SexAgeEk\")\n .iloc[:, 0]\n .str.split(\"/ \", expand=True)\n .rename(columns={0: \"md_sex\", 1: \"md_agenatrep\", 2: \"md_ek\"})\n )\n }\n return data","def open_from(self, f: BinaryIO):\n raise NotImplementedError","def _load_file(self):\n getLogger(__name__).debug(\"Loading {} in {} mode.\".format(self.filename, self.mode))\n try:\n kwargs = {'driver': 'H5FD_CORE'} if self.in_memory else {}\n self.file = tables.open_file(self.filename, mode='a' if self.mode == 'write' else 'r', **kwargs)\n except (IOError, OSError):\n raise\n\n # get important cal params\n self.nominal_wavelength_bins = self.nyquist_wavelengths()\n\n # get the beam image\n self.beamImage = self.file.get_node('/beammap/map').read()\n self._flagArray = self.file.get_node('/beammap/flag') # The absence of .read() here is correct\n self.nXPix, self.nYPix = self.beamImage.shape\n\n # get the photontable\n self.photonTable = self.file.get_node('/photons/photontable')","def load(self, filename):\n raise NotImplementedError","def load_data(self):\n raise NotImplementedError()","def load_data():\r\n print ('Loadng all the file one time......')\r\n if not os.path.exists('cifar.pkl'):\r\n set_data()\r\n with open('cifar.pkl', 'rb') as cifar_pickle:\r\n data = six.moves.cPickle.load(cifar_pickle)\r\n return data","def load_file():\n global list_of_table, data_base, new_data\n open_name = askopenfilename()\n\n if Path(open_name).suffix == '.db':\n data_base = open_name\n data_base = str(data_base)\n new_data_base = parse(data_base)\n new_data = update_list_tables(new_data_base)\n new_data.clear()\n\n else:\n mistake_db_file()","def load(self, ocadfile=None):\n if ocadfile:\n (ocadName, ext) = os.path.splitext(ocadfile)\n self.ocadName = ocadName\n else:\n raise OcadfileException(\"File not specified!\")\n \n try:\n self.__open()\n self.block = None\n self.syhdr = None\n self.StringsStorage = None\n \n if self.ocad:\n self.__ocadHeader()\n self.__symbolsHeader() # Version <= 8\n self.__setup() # Version <= 8\n \n finally: \n self.__close()","def load_file(*args, **kwargs): # real signature unknown\n pass","def load(self) -> None:\n self._load_data()\n self._load_poses()\n self._load_timestamps()","def load(self, filename=None):\n importer = aspecd.io.AdfImporter()\n importer.source = filename\n importer.import_into(self)","def load(self):\n\n raise NotImplementedError","def load(self, input):","def load(self):","def loadData(self, file):\n self.data = batchImport(file, self.ps)","def load(self):\n pass","def load(self):\n pass","def load(self):\n pass","def load(self):\n pass","def load(self, input):\n pass","def load_test_file():\n hou.hipFile.load(\n os.path.join(\n os.path.dirname(os.path.abspath(__file__)),\n \"data\",\n \"test_api_integration.hipnc\",\n ),\n ignore_load_warnings=True,\n )\n\n yield\n\n hou.hipFile.clear()","def _read(self):\n # initializng data dictionary\n self.data={}\n\n f = FortranFile(self.filename)\n # Default omnivor binary header\n self.data['MK'] = f.readInts('i')\n self.data['itime'] = f.readInts('i')\n self.data['version'] = f.readString()\n self.data['file_id'] = f.readInts('i')\n self.data['sversion'] = f.readString()\n # Velocity field\n self.data['stype'] = f.readString()\n self.data['is_grid'] = f.readInts('i')\n nCPs = f.readInts('i')\n self.data['nCPs'] = nCPs\n if self.data['MK'] == 8:\n real_char='d'\n else:\n real_char='f'\n if self.data['is_grid']:\n #print('File is a velocity grid file')\n n1 = f.readInts('i')\n n2 = f.readInts('i')\n n3 = f.readInts('i')\n self.data['n1'] = n1\n self.data['n2'] = n2\n self.data['n3'] = n3\n self.data['is_straight'] = f.readInts('i')\n self.data['v1'] = f.readReals(real_char)\n self.data['v2'] = f.readReals(real_char)\n self.data['v3'] = f.readReals(real_char)\n\n CPs_raw = f.readReals(real_char)\n Utot_raw = f.readReals(real_char)\n CPs = np.reshape(CPs_raw,(3,nCPs),order = 'F')\n Utot = np.reshape(Utot_raw,(3,nCPs),order = 'F')\n\n acc=-1\n CPsTab = np.zeros((3, n1,n2,n3))\n UtotTab = np.zeros((3, n1,n2,n3))\n # Reshaping the nasty way (this is natural order). \n for i in range(0,n1):\n for j in range(0,n2):\n for k in range(0,n3):\n acc=acc+1\n CPsTab[0:3,i,j,k] = CPs[0:3,acc]\n UtotTab[0:3,i,j,k] = Utot[0:3,acc]\n\n self.data['CPs'] = CPs\n self.data['CPsTab'] = CPsTab\n self.data['Utot'] = Utot\n self.data['UtotTab'] = UtotTab","def load_all_data_from_file(self) -> None:\n self.load_gene_data_from_file()\n self.load_ontology_from_file(ontology_type=DataType.GO, ontology_url=self.go_ontology_url,\n ontology_cache_path=self.go_ontology_cache_path,\n config=self.config)\n self.load_associations_from_file(associations_type=DataType.GO, associations_url=self.go_associations_url,\n associations_cache_path=self.go_associations_cache_path, config=self.config)\n self.load_ontology_from_file(ontology_type=DataType.DO, ontology_url=self.do_ontology_url,\n ontology_cache_path=self.do_ontology_cache_path, config=self.config)\n self.load_associations_from_file(associations_type=DataType.DO, associations_url=self.do_associations_url,\n associations_cache_path=self.do_associations_cache_path,\n association_additional_cache_path=self.do_associations_new_cache_path,\n association_additional_url=self.do_associations_new_url, config=self.config)\n self.load_ontology_from_file(ontology_type=DataType.EXPR, ontology_url=self.expression_ontology_url,\n ontology_cache_path=self.expression_ontology_cache_path, config=self.config)\n self.load_associations_from_file(associations_type=DataType.EXPR,\n associations_url=self.expression_associations_url,\n associations_cache_path=self.expression_associations_cache_path,\n config=self.config)\n self.load_orthology_from_file()\n self.load_expression_cluster_data()\n self.load_protein_domain_information()","def load_model(self, filename):\r\n pass","def test1_loading(self):\n\t\tprint \"\\nTEST 1: Loading ontologies from %s folder.\\n=================\" % DATA_FOLDER\n\t\t\n\t\tfor f in os.listdir(DATA_FOLDER):\n\t\t\tif not f.startswith('.'):\n\t\t\t\tprint \"Loading... >\", f\t\t\n\t\t\t\t\n\t\t\t\to = ontospy.Ontology(DATA_FOLDER + f)\n\t\t\t\t\n\t\t\t\tself.assertEqual(type(o), ontospy.Ontology)\n\t\t\t\tprint \"Success.\"","def get_model_data_from_files(self, oc):\r\n # Load model related files\r\n model_path = self.config['DATA_PATH'] + self.config['CUSTOMER_NAME'] + '/models/'\r\n\r\n features_file = model_path + self.task + '_' + str(oc) + '_features.txt'\r\n dummies_file = model_path + self.task + '_' + str(oc) + '_dummies.txt'\r\n model_file = model_path + self.task + '_' + str(oc) + '.joblib'\r\n\r\n if os.path.isfile(features_file) and os.path.isfile(dummies_file) and os.path.isfile(model_file):\r\n model = joblib.load(model_file)\r\n features = open(features_file, 'r', encoding=self.config['DATA_ENCODING']).read().rstrip('\\n').split(self.config['DATA_SEPARATOR'])\r\n dummies = open(dummies_file, 'r', encoding=self.config['DATA_ENCODING']).read().rstrip('\\n').split(self.config['DATA_SEPARATOR'])\r\n return (model, features, dummies)\r\n return (None, None, None)","def dataLoad():\n try:\n try: #Python3\n f = open(__file__ + \".csv\",\"rt\")\n except: #Python2\n f = open(__file__ + \".csv\",\"rb\")\n data = f.read().split(',')\n entryCol.entry0.delete(0,END)\n entryCol.entry0.insert(0,data[0])\n entryCol.entry1.delete(0,END)\n entryCol.entry1.insert(0,data[1])\n entryCol.entry2.delete(0,END)\n entryCol.entry2.insert(0,data[2])\n entryCol.entry3.delete(0,END)\n entryCol.entry3.insert(0,data[3])\n botWind.writeN(\"DataLoad: File\")\n except:\n botWind.writeN(\"DataLoad: Default\")","def _load_obcfile(casename=None): \n\n data={}\n\n if casename==None:\n print('_load_obcfile requires a filename to load.')\n return\n try:\n fp=open(casename+'_obc.dat','r')\n except IOError:\n print('_load_obcfile: invalid case name.')\n return data\n\n obc_str=fp.readline().split('=')\n obc_num=int(obc_str[1])\n t_data1=np.genfromtxt(casename+'_obc.dat',skip_header=1)\n fp.close()\n\n data['obcf_num']=obc_num\n data['obcf_numbers']=t_data1[:,0]\n data['obcf_nodes']=t_data1[:,1]\n data['obcf_value']=t_data1[:,2]\n\n \n return data","def load(self):\n raise NotImplementedError","def load(self):\n raise NotImplementedError","def read_data(feature_file, label_file):","def load(cls, f, model, ext_unit_dict=None):\n msg = (\n \"Model object must be of type flopy.mfusg.MfUsg\\n\"\n f\"but received type: {type(model)}.\"\n )\n assert isinstance(model, MfUsg), msg\n\n if model.verbose:\n print(\"loading bcf package file...\")\n\n f_obj = get_open_file_object(f, \"r\")\n\n # dataset 0 -- header\n while True:\n line = f_obj.readline()\n if line[0] != \"#\":\n break\n\n # determine problem dimensions\n nlay = model.nlay\n dis = model.get_package(\"DIS\")\n if dis is None:\n dis = model.get_package(\"DISU\")\n njag = dis.njag\n\n # Item 1: ipakcb, HDRY, IWDFLG, WETFCT, IWETIT, IHDWET - line already read above\n if model.verbose:\n print(\" loading ipakcb, HDRY, IWDFLG, WETFCT, IWETIT, IHDWET...\")\n text_list = line_parse(line)\n ipakcb, hdry, iwdflg, wetfct, iwetit, ihdwet = (\n int(text_list[0]),\n float(text_list[1]),\n int(text_list[2]),\n float(text_list[3]),\n int(text_list[4]),\n int(text_list[5]),\n )\n\n ikvflag = type_from_iterable(\n text_list, index=6, _type=int, default_val=0\n )\n ikcflag = type_from_iterable(\n text_list, index=7, _type=int, default_val=0\n )\n\n # LAYCON array\n laycon, intercellt = cls._load_laycon(f_obj, model)\n\n # TRPY array\n if model.verbose:\n print(\" loading TRPY...\")\n trpy = Util2d.load(\n f_obj, model, (nlay,), np.float32, \"trpy\", ext_unit_dict\n )\n\n # property data for each layer based on options\n transient = not dis.steady.all()\n anis = any(t != 1 for t in trpy)\n anglex = 0\n if (not model.structured) and anis:\n if model.verbose:\n print(\"loading ANGLEX...\")\n anglex = Util2d.load(\n f_obj, model, (njag,), np.float32, \"anglex\", ext_unit_dict\n )\n\n # hy, kv, storage\n (sf1, tran, hy, vcont, sf2, wetdry, kv) = cls._load_layer_arrays(\n f_obj,\n model,\n nlay,\n ext_unit_dict,\n transient,\n laycon,\n ikvflag,\n ikcflag,\n iwdflg,\n )\n\n # Ksat mfusg\n ksat = 0\n if (not model.structured) and abs(ikcflag == 1):\n if model.verbose:\n print(\" loading ksat (njag)...\")\n ksat = Util2d.load(\n f_obj, model, (njag,), np.float32, \"ksat\", ext_unit_dict\n )\n\n f_obj.close()\n\n # set package unit number\n unitnumber, filenames = get_unitnumber_from_ext_unit_dict(\n model, cls, ext_unit_dict, ipakcb\n )\n\n # create instance of bcf object\n bcf = cls(\n model,\n ipakcb=ipakcb,\n intercellt=intercellt,\n laycon=laycon,\n trpy=trpy,\n hdry=hdry,\n iwdflg=iwdflg,\n wetfct=wetfct,\n iwetit=iwetit,\n ihdwet=ihdwet,\n ikvflag=ikvflag,\n ikcflag=ikcflag,\n tran=tran,\n hy=hy,\n vcont=vcont,\n kv=kv,\n anglex=anglex,\n ksat=ksat,\n sf1=sf1,\n sf2=sf2,\n wetdry=wetdry,\n unitnumber=unitnumber,\n filenames=filenames,\n )\n\n # return bcf object\n return bcf","def _load(self):\n if self.file_path.exists():\n with open(self.file_path) as fid:\n self.data = json.load(fid)","def _load(self):\n raise NotImplementedError()","def Load(self):\n\t\tfile = open(self.fileName, 'r')\n\t\tself.hdr = file.readline().split('\\n')[0].split(',')\n\t\t\n\t\tfor line in file.readlines():\n\t\t\ttokens = line.split('\\n')[0].split(',')\n\t\t\tif int(tokens[1]) == 0:\n\t\t\t\tself.h0.append(tokens[0])\n\t\t\telse:\n\t\t\t\tself.h1.append(tokens[0])\n\t\tfile.close()\n\t\tself.numH1 = len(self.h1)\n\t\tself.numH0 = len(self.h0)","def load_model_file(device_index):\n print(\"\\nStart loading model...\")\n\n return kdp_wrapper.isi_load_nef(device_index, MODEL_FILE, ISI_APP_ID)","def load(self):\n #print self.fileInfo.name\n progress = self.progress\n filePath = os.path.join(self.fileInfo.dir,self.fileInfo.name)\n self.fileSize = os.path.getsize(filePath)\n #--Localize\n cells = self.cells\n records = self.records\n canSave = self.canSave\n skipObjRecords = self.skipObjRecords\n contTypes = set(['CREC','CNTC','NPCC'])\n levTypes = set(('LEVC','LEVI'))\n debrisIds = self.debrisIds\n debrisTypes = set(debrisIds.keys())\n #--Header\n inPath = os.path.join(self.fileInfo.dir,self.fileInfo.name)\n ins = Tes3Reader(self.fileInfo.name,file(inPath,'rb'))\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\n self.tes3 = Tes3(name,size,delFlag,recFlag,ins,True)\n if not canSave: del self.tes3.others[:]\n #--Progress info\n progress = self.progress\n progress(0.0,'Loading '+self.fileInfo.name)\n #--Raw data read\n while not ins.atEnd():\n #--Get record info and handle it\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\n #print \"%s [%d]\" % (name,size)\n #--CELL?\n if name == 'CELL':\n record = Cell(name,size,delFlag,recFlag,ins,0,skipObjRecords)\n cells.append(record)\n if canSave: records.append(record)\n #--Contents\n elif canSave and name in contTypes:\n if name == 'CREC':\n record = Crec(name,size,delFlag,recFlag,ins,True)\n elif name == 'CNTC':\n record = Cntc(name,size,delFlag,recFlag,ins,True)\n else:\n record = Npcc(name,size,delFlag,recFlag,ins,True)\n self.conts.append(record)\n self.conts_id[record.getId()] = record\n records.append(record)\n #--File Map\n elif name == 'FMAP':\n record = Fmap(name,size,delFlag,recFlag,ins)\n self.fmap = record\n records.append(record)\n #--Landscapes\n elif name == 'LAND':\n record = Land(name,size,delFlag,recFlag,ins)\n self.lands[record.getId()] = record\n records.append(record)\n #--Scripts\n elif canSave and name == 'SCPT':\n record = Scpt(name,size,delFlag,recFlag,ins,True)\n records.append(record)\n if record.getRef():\n self.refs_scpt[record] = record.getRef()\n #--Save debris info?\n elif name in debrisTypes:\n record = Record(name,size,delFlag,recFlag,ins)\n id = record.getId()\n if id:\n debrisIds[name].append(id.lower())\n if canSave:\n records.append(record)\n #--Skip Non-cell?\n elif not canSave:\n ins.seek(size,1,name)\n #--Keep non-cell?\n else:\n records.append(Record(name,size,delFlag,recFlag,ins))\n #--Done Reading\n ins.close()\n #--Analyze Cells\n cntCells = 0\n progress.setMax(len(self.cells))\n for cell in self.cells:\n cell.load(None,1)\n self.cells_id[cell.getId()] = cell\n if not canSave:\n cell.data = None #--Free some memory\n #--Progress\n cntCells += 1\n progress(cntCells)\n #--Scripts\n if self.refs_scpt:\n self.updateScptRefs()","def import_data_helper(self): \n if len(self.components) == 1:\n hapi.fetch(TableName = self.tablename, M = self.components[0][0], I = self.components[0][1], numin = self.min_x, numax = self.max_x)\n else: \n global_id = []\n for c in self.components:\n global_id.append(hapi.ISO[c][0])\n hapi.fetch_by_ids(TableName = self.tablename, iso_id_list = global_id, numin = self.min_x, numax = self.max_x)","def load(file_name):\n ferme_fenetre()\n Hitori(file_name)","def load_binary_data(self, encoding='utf8'):\n\n # TODO use smart_open again when https://github.com/RaRe-Technologies/smart_open/issues/207 will be fixed\n with open(self.file_name, 'rb') as f:\n self.load_model_params(f)\n self.load_dict(f, encoding=encoding)\n self.load_vectors(f)","def loaditems(self, fh):\n pass","def main():\n print \"=\" * 78\n print \"%s %s\" % (__prog_name__, __version__)\n debug, input_file_names = check_cli()\n if not input_file_names:\n _error(\"No input file name found!\\n\\n%s\" % __help__)\n for input_file_name in input_file_names:\n print \"* Reading\", input_file_name\n file_base_name = os.path.splitext(os.path.basename(input_file_name))[0]\n file_dir_name = os.path.dirname(input_file_name)\n sections = {}\n tex_map = {}\n with open(input_file_name, 'rU') as in_fd:\n sections = get_sections(in_fd.read())\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"sec\",\n {\"sections\": sections})\n\n if not sections:\n _error(\"Nothing could be read from '%s'.\\nIs this an Oolite .dat file?\" \\\n % input_file_name)\n\n # Magically call the 'check' functions\n for name in sections.keys():\n f_name = \"check_%s\" % name.lower()\n if f_name in globals().keys():\n if not globals()[f_name](sections):\n _error(\"Number of entries in '%s' section is different as declared!\" % name)\n\n def get_data(name, sections=sections):\n \"\"\"Returns the 'data' object from the 'name' one found in the\n 'sections' one.\n :sections: dictionary: Object returned by 'get_sections'.\n :name: string: The name of the section to get the 'data'.\n Returns a list of 'lines'.\n \"\"\"\n return sections.get(name, {}).get(\"data\", [])\n\n oti_file_name = build_file_path(file_dir_name, file_base_name, \"oti\")\n tex_map = parse_names(get_data(\"NAMES\"), oti_file_name)\n\n tex_refs, tex_lines_out = parse_textures(get_data(\"TEXTURES\"))\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"tex\",\n {\"tex_refs\": tex_refs,\n \"tex_lines_out\": tex_lines_out})\n\n # Update the tex_map object if textures indexes and names are both\n # used in 'TEXTURES'.\n if sorted(tex_map.keys()) != sorted(tex_refs.get(\"named\").keys()):\n tex_map = update_tex_map(tex_map,\n set(tex_refs[\"named\"].keys()).difference(tex_map.keys()))\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"txm\",\n {\"tex_map\": tex_map})\n\n n_verts, vertex_lines_out = parse_vertex(get_data(\"VERTEX\"))\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"ver\",\n {\"n_verts\": n_verts,\n \"vertex_lines_out\": vertex_lines_out})\n\n n_normals, normals_lines_out = parse_normals(get_data(\"NORMALS\"))\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"nor\",\n {\"n_normals\": n_normals,\n \"normals_lines_out\": normals_lines_out})\n\n n_faces, faces_groups = parse_faces(get_data(\"FACES\"), tex_refs,\n normals_lines_out)\n\n if debug:\n write_dump_file(file_dir_name, file_base_name, \"fac\",\n {\"n_faces\": n_faces,\n \"faces_groups\": faces_groups})\n\n output_file_name = build_file_path(file_dir_name,\n file_base_name, 'obj')\n material_file_name = build_file_path(file_dir_name,\n file_base_name, 'mtl')\n mtl_lib_file = os.path.basename(material_file_name)\n\n write_obj(output_file_name, file_base_name, mtl_lib_file,\n tex_lines_out, tex_map, n_verts, vertex_lines_out,\n n_normals, normals_lines_out, n_faces, faces_groups)\n\n write_mtl(material_file_name, tex_map)\n\n _exit(\"* Done\")","def loadIni(self):\n reLoadFiles = re.compile(r'^\\[Game Files\\](.*)')\n reLoadFile = re.compile(r'GameFile[0-9]+=(.*)$')\n #--Read file\n self.mtime = getmtime(self.path)\n self.size = os.path.getsize(self.path)\n ins = file(self.path,'rt')\n #--Pre-Load Lines\n del self.preLoadLines[:]\n del self.postLoadLines[:]\n while True:\n line = ins.readline()\n if not line: \n ins.close()\n raise Tes3Error('Morrowind.ini', _('Morrowind.ini: [GameFiles] section not found.'))\n maLoadFiles = reLoadFiles.match(line)\n if maLoadFiles: break\n self.preLoadLines.append(line)\n #--Load Files \n self.loadFilesComment = maLoadFiles.group(1)\n del self.loadFiles[:]\n del self.loadFilesBad[:]\n while True:\n line = ins.readline()\n maLoadFile = reLoadFile.match(line)\n if not maLoadFile: \n if line: self.postLoadLines.append(line)\n break\n loadFile = unicode(maLoadFile.group(1), 'latin-1')\n loadPath = os.path.join(self.dir,'Data Files',loadFile)\n loadExt = os.path.splitext(loadPath)[-1].lower()\n if len(self.loadFiles) == 255:\n self.loadFilesExtra.append(loadFile)\n elif os.path.exists(loadPath) and re.match('^\\.es[pm]$',loadExt):\n self.loadFiles.append(loadFile)\n else:\n self.loadFilesBad.append(loadFile)\n #--Post-Load Lines\n while True:\n line = ins.readline()\n if not line: break\n self.postLoadLines.append(line)\n #--Done\n ins.close()","def load(self,filename=None): # return True\r\n pass","def _load(self):\n\n # number of non-data header details at top of data file\n header = 1\n\n # open file\n weatherData = []\n with open(self.wfile) as myfile:\n if (self.lines > 0):\n weatherData = [next(myfile) for x in xrange(self.lines + header)]\n else:\n weatherData = myfile.readlines()\n\n # get data stream from first line\n streamHeader = weatherData.pop(0).rstrip()\n if (streamHeader == 'FULL'):\n self.dataStream = 0\n elif (streamHeader == 'ADVANCED'):\n self.dataStream = 1\n elif (streamHeader == 'BASIC'):\n self.dataStream = 2\n else:\n print \"Error: unecognised data stream from file %s\" % (self.wfile)\n return -1\n\n # read data\n inputData = []\n for line in weatherData:\n entries = line.split()\n inputData.append(entries)\n\n # copy all into np array\n self.data = np.array(inputData)\n\n return 0","def load_data():\r\n global labelNames\r\n print(\"Loading Data...\")\r\n\r\n fnpath = \"rawdata\\\\cifar-10-batches-py\"\r\n fnprefix = 'data_batch_'\r\n fnlblnames = 'batches.meta'\r\n fntstbatch = 'test_batch'\r\n\r\n labelNames = unpickle(path.join(fnpath, fnlblnames))\r\n label_names = []\r\n for label in labelNames['label_names']:\r\n label_names.append(\"\".join(map(chr, label)))\r\n labelNames['label_names'] = label_names\r\n\r\n CIFAR_Data.append(unpickle(path.join(fnpath, fntstbatch)))\r\n for n in range(1, 6):\r\n CIFAR_Data.append(unpickle(path.join(fnpath, fnprefix + str(n))))","def load(fnames, tag='', inst_id=''):\n\n # Save each file to the output DataFrame\n data = load_csv_data(fnames, read_csv_kwargs={'index_col': 0,\n 'parse_dates': True})\n\n # Assign the meta data\n meta, status_desc = mm_ace.common_metadata()\n flux_desc = '5-min averaged Differential '\n\n meta['status_e'] = {meta.labels.units: '',\n meta.labels.name: 'Diff e- Flux Status',\n meta.labels.notes: '',\n meta.labels.desc: status_desc,\n meta.labels.fill_val: np.nan,\n meta.labels.min_val: 0,\n meta.labels.max_val: 9}\n meta['status_p'] = {meta.labels.units: '',\n meta.labels.name: 'Diff Proton Flux Status',\n meta.labels.notes: '',\n meta.labels.desc: status_desc,\n meta.labels.fill_val: np.nan,\n meta.labels.min_val: 0,\n meta.labels.max_val: 9}\n meta['anis_ind'] = {meta.labels.units: '',\n meta.labels.name: 'Anisotropy Index',\n meta.labels.notes: '',\n meta.labels.desc: 'Range: 0.0 - 2.0',\n meta.labels.fill_val: -1.0,\n meta.labels.min_val: 0.0,\n meta.labels.max_val: 2.0}\n meta['eflux_38-53'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name: 'Diff e- Flux 38-53 eV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Electron Flux between 35-53 eV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n meta['eflux_175-315'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name: 'Diff e- Flux 175-315 eV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Electron Flux between 175-315 eV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n meta['pflux_47-68'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name: 'Diff Proton Flux 47-68 keV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Proton Flux between 47-68 keV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n meta['pflux_115-195'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name: 'Diff Proton Flux 115-195 keV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Proton Flux between 115-195 keV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n meta['pflux_310-580'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name: 'Diff Proton Flux 310-580 keV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Proton Flux between 310-580 keV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n meta['pflux_795-1193'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name: 'Diff Proton Flux 795-1193 keV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Proton Flux between 795-1193 keV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n meta['pflux_1060-1900'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name:\n 'Diff Proton Flux 1060-1900 keV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Proton Flux between 1060-1900 keV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n return data, meta","def load_data(filename) :\r\n data = Data()\r\n data.load(filename)\r\n return data","def load(self):\n self.data = NSPSpecIO().read(self.path)","def _read_raw_file(\n self, fname, allow_maxshield, preload, do_check_ext=True, verbose=None\n ):\n logger.info(\"Opening raw data file %s...\" % fname)\n\n # Read in the whole file if preload is on and .fif.gz (saves time)\n if not _file_like(fname):\n if do_check_ext:\n endings = (\n \"raw.fif\",\n \"raw_sss.fif\",\n \"raw_tsss.fif\",\n \"_meg.fif\",\n \"_eeg.fif\",\n \"_ieeg.fif\",\n )\n endings += tuple([f\"{e}.gz\" for e in endings])\n check_fname(fname, \"raw\", endings)\n # filename\n fname = str(_check_fname(fname, \"read\", True, \"fname\"))\n ext = os.path.splitext(fname)[1].lower()\n whole_file = preload if \".gz\" in ext else False\n del ext\n else:\n # file-like\n if not preload:\n raise ValueError(\"preload must be used with file-like objects\")\n whole_file = True\n fname_rep = _get_fname_rep(fname)\n ff, tree, _ = fiff_open(fname, preload=whole_file)\n with ff as fid:\n # Read the measurement info\n\n info, meas = read_meas_info(fid, tree, clean_bads=True)\n annotations = _read_annotations_fif(fid, tree)\n\n # Locate the data of interest\n raw_node = dir_tree_find(meas, FIFF.FIFFB_RAW_DATA)\n if len(raw_node) == 0:\n raw_node = dir_tree_find(meas, FIFF.FIFFB_CONTINUOUS_DATA)\n if len(raw_node) == 0:\n raw_node = dir_tree_find(meas, FIFF.FIFFB_IAS_RAW_DATA)\n if len(raw_node) == 0:\n raise ValueError(\"No raw data in %s\" % fname_rep)\n _check_maxshield(allow_maxshield)\n with info._unlock():\n info[\"maxshield\"] = True\n del meas\n\n if len(raw_node) == 1:\n raw_node = raw_node[0]\n\n # Process the directory\n directory = raw_node[\"directory\"]\n nent = raw_node[\"nent\"]\n nchan = int(info[\"nchan\"])\n first = 0\n first_samp = 0\n first_skip = 0\n\n # Get first sample tag if it is there\n if directory[first].kind == FIFF.FIFF_FIRST_SAMPLE:\n tag = read_tag(fid, directory[first].pos)\n first_samp = int(tag.data.item())\n first += 1\n _check_entry(first, nent)\n\n # Omit initial skip\n if directory[first].kind == FIFF.FIFF_DATA_SKIP:\n # This first skip can be applied only after we know the bufsize\n tag = read_tag(fid, directory[first].pos)\n first_skip = int(tag.data.item())\n first += 1\n _check_entry(first, nent)\n\n raw = _RawShell()\n raw.filename = fname\n raw.first_samp = first_samp\n if info[\"meas_date\"] is None and annotations is not None:\n # we need to adjust annotations.onset as when there is no meas\n # date set_annotations considers that the origin of time is the\n # first available sample (ignores first_samp)\n annotations.onset -= first_samp / info[\"sfreq\"]\n raw.set_annotations(annotations)\n\n # Go through the remaining tags in the directory\n raw_extras = list()\n nskip = 0\n orig_format = None\n\n for k in range(first, nent):\n ent = directory[k]\n # There can be skips in the data (e.g., if the user unclicked)\n # an re-clicked the button\n if ent.kind == FIFF.FIFF_DATA_SKIP:\n tag = read_tag(fid, ent.pos)\n nskip = int(tag.data.item())\n elif ent.kind == FIFF.FIFF_DATA_BUFFER:\n # Figure out the number of samples in this buffer\n if ent.type == FIFF.FIFFT_DAU_PACK16:\n nsamp = ent.size // (2 * nchan)\n elif ent.type == FIFF.FIFFT_SHORT:\n nsamp = ent.size // (2 * nchan)\n elif ent.type == FIFF.FIFFT_FLOAT:\n nsamp = ent.size // (4 * nchan)\n elif ent.type == FIFF.FIFFT_DOUBLE:\n nsamp = ent.size // (8 * nchan)\n elif ent.type == FIFF.FIFFT_INT:\n nsamp = ent.size // (4 * nchan)\n elif ent.type == FIFF.FIFFT_COMPLEX_FLOAT:\n nsamp = ent.size // (8 * nchan)\n elif ent.type == FIFF.FIFFT_COMPLEX_DOUBLE:\n nsamp = ent.size // (16 * nchan)\n else:\n raise ValueError(\n \"Cannot handle data buffers of type \" \"%d\" % ent.type\n )\n if orig_format is None:\n if ent.type == FIFF.FIFFT_DAU_PACK16:\n orig_format = \"short\"\n elif ent.type == FIFF.FIFFT_SHORT:\n orig_format = \"short\"\n elif ent.type == FIFF.FIFFT_FLOAT:\n orig_format = \"single\"\n elif ent.type == FIFF.FIFFT_DOUBLE:\n orig_format = \"double\"\n elif ent.type == FIFF.FIFFT_INT:\n orig_format = \"int\"\n elif ent.type == FIFF.FIFFT_COMPLEX_FLOAT:\n orig_format = \"single\"\n elif ent.type == FIFF.FIFFT_COMPLEX_DOUBLE:\n orig_format = \"double\"\n\n # Do we have an initial skip pending?\n if first_skip > 0:\n first_samp += nsamp * first_skip\n raw.first_samp = first_samp\n first_skip = 0\n\n # Do we have a skip pending?\n if nskip > 0:\n raw_extras.append(\n dict(\n ent=None,\n first=first_samp,\n nsamp=nskip * nsamp,\n last=first_samp + nskip * nsamp - 1,\n )\n )\n first_samp += nskip * nsamp\n nskip = 0\n\n # Add a data buffer\n raw_extras.append(\n dict(\n ent=ent,\n first=first_samp,\n last=first_samp + nsamp - 1,\n nsamp=nsamp,\n )\n )\n first_samp += nsamp\n\n next_fname = _get_next_fname(fid, fname_rep, tree)\n\n # reformat raw_extras to be a dict of list/ndarray rather than\n # list of dict (faster access)\n raw_extras = {key: [r[key] for r in raw_extras] for key in raw_extras[0]}\n for key in raw_extras:\n if key != \"ent\": # dict or None\n raw_extras[key] = np.array(raw_extras[key], int)\n if not np.array_equal(raw_extras[\"last\"][:-1], raw_extras[\"first\"][1:] - 1):\n raise RuntimeError(\"FIF file appears to be broken\")\n bounds = np.cumsum(\n np.concatenate([raw_extras[\"first\"][:1], raw_extras[\"nsamp\"]])\n )\n raw_extras[\"bounds\"] = bounds\n assert len(raw_extras[\"bounds\"]) == len(raw_extras[\"ent\"]) + 1\n # store the original buffer size\n buffer_size_sec = np.median(raw_extras[\"nsamp\"]) / info[\"sfreq\"]\n del raw_extras[\"first\"]\n del raw_extras[\"last\"]\n del raw_extras[\"nsamp\"]\n\n raw.last_samp = first_samp - 1\n raw.orig_format = orig_format\n\n # Add the calibration factors\n cals = np.zeros(info[\"nchan\"])\n for k in range(info[\"nchan\"]):\n cals[k] = info[\"chs\"][k][\"range\"] * info[\"chs\"][k][\"cal\"]\n\n raw._cals = cals\n raw._raw_extras = raw_extras\n logger.info(\n \" Range : %d ... %d = %9.3f ... %9.3f secs\"\n % (\n raw.first_samp,\n raw.last_samp,\n float(raw.first_samp) / info[\"sfreq\"],\n float(raw.last_samp) / info[\"sfreq\"],\n )\n )\n\n raw.info = info\n\n logger.info(\"Ready.\")\n\n return raw, next_fname, buffer_size_sec","def test_readfile(self):\n fname = os.path.join(self.datadir, 'monol_testA_E3-50_rebin4_gti') + \\\n HEN_FILE_EXTENSION\n command = \"{0}\".format(fname)\n\n hen.io.main(command.split())","def load(self,factory={}):\n canSave = self.canSave\n #--Header\n inPath = os.path.join(self.fileInfo.dir,self.fileInfo.name)\n ins = Tes3Reader(self.fileInfo.name,file(inPath,'rb'))\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\n self.tes3 = Tes3(name,size,delFlag,recFlag,ins,True)\n #--Raw data read\n dial = None\n while not ins.atEnd():\n #--Get record info and handle it\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\n #--SCPT?\n if name == 'SCPT':\n record = Scpt(name,size,delFlag,recFlag,ins,True)\n self.scripts.append(record)\n if canSave: self.records.append(record)\n #--Non-dials?\n elif canSave:\n record = Record(name,size,delFlag,recFlag,ins)\n self.records.append(record)\n else:\n ins.seek(size,1,'Record')\n #--Done Reading\n ins.close()","def load_main_function(self, options, data=None):\n\n if self.rdmc.app.redfishinst.is_redfish:\n eth_type = \"ethernetinterface.\"\n else:\n eth_type = \"ethernetnetworkinterface.\"\n\n linking_dict = {\n \"manager_interfaces\": eth_type,\n \"systems_interfaces\": eth_type,\n \"manager_network_services\": \"networkprotocol.\",\n \"ilo_date_time\": \"datetime.\",\n }\n\n if not data:\n data = {}\n try:\n if options.encryption:\n with open(self.eth_file, \"rb\") as file_handle:\n data = json.loads(\n Encryption().decrypt_file(\n file_handle.read(), options.encryption\n )\n )\n else:\n with open(self.eth_file, \"rb\") as file_handle:\n data = json.loads(file_handle.read())\n except:\n raise InvalidFileInputError(\n \"Invalid file formatting found. Verify the file has a \"\n \"valid JSON format.\"\n )\n\n for ilotype, subsect in data.items():\n _type = ilotype.split(\".\")[0]\n for _path in subsect:\n if not subsect[_path]:\n continue\n elif (\n \"ethernetinterface\" in _type.lower()\n or \"ethernetnetworkinterface\" in _type.lower()\n ):\n if \"managers\" in _path.lower():\n self.load_ethernet_aux(_type, _path, data[ilotype][_path])\n elif \"systems\" in _path.lower():\n self.rdmc.ui.warn(\n \"Systems Ethernet Interfaces '%s' \"\n \"cannot be modified.\" % _path\n )\n continue\n elif \"datetime\" in _type.lower():\n if \"StaticNTPServers\" in list(subsect.get(_path).keys()):\n # must set NTP Servers to static in OEM then reset iLO for StaticNTPServers\n # property to appear in iLODateTime\n if self.rdmc.app.redfishinst.is_redfish:\n eth_config_type = \"ethernetinterface\"\n else:\n eth_config_type = \"ethernetnetworkinterface\"\n for key in list(data.keys()):\n if key.split(\".\")[0].lower() == eth_config_type:\n eth_config_type = key\n for _path in data[eth_config_type]:\n if \"managers\" in _path.lower():\n try:\n data[eth_config_type][_path][\"DHCPv4\"][\n \"UseNTPServers\"\n ] = True\n data[eth_config_type][_path][\"DHCPv6\"][\n \"UseNTPServers\"\n ] = True\n data[eth_config_type][_path][\"Oem\"][\n self.rdmc.app.typepath.defs.oemhp\n ][\"DHCPv4\"][\"UseNTPServers\"] = True\n data[eth_config_type][_path][\"Oem\"][\n self.rdmc.app.typepath.defs.oemhp\n ][\"DHCPv6\"][\"UseNTPServers\"] = True\n self.load_ethernet_aux(\n eth_config_type,\n _path,\n data[eth_config_type][_path],\n )\n except KeyError:\n self.rdmc.ui.printer(\n \"Unable to configure \"\n \"'UseNTPServers' for '%s'.\\n\" % _path\n )\n self.rdmc.ui.printer(\n \"iLO must be reset in order for \"\n \"changes to static network time protocol servers to \"\n \"take effect.\\n\"\n )","def test_load(api):\n # upload file to file.io servers\n uploaded_file = api.upload(\n tag='test_file',\n expiry='1d',\n path='tests/test_file.txt'\n )\n\n # check that instance of FileIO has these fields\n assert uploaded_file.link\n assert uploaded_file.key\n assert uploaded_file.tag\n assert uploaded_file.path\n\n # check that the uploaded file was added to uploaded files list\n assert api.show_uploads()\n\n # check that our list is not empty\n assert api.file_obj_list\n\n # export the file in json format\n api.export('tests/exported.json')\n\n # check that exported file exists\n assert path.isfile('tests/exported.json')\n\n # set it to empty list\n api.file_obj_list = []\n\n # load the file in json format\n api.load('tests/exported.json')\n\n # remove the file\n remove('tests/exported.json')\n\n # check that the uploaded file was added to uploaded files list\n assert api.show_uploads()\n\n # check that our list is not empty\n assert api.file_obj_list\n\n # export the file in pkl format\n api.export('tests/exported.pkl')\n\n # set it to empty list\n api.file_obj_list = []\n\n # load the file in pkl format\n api.load('tests/exported.pkl')\n\n # remove exported.pkl file\n remove('tests/exported.pkl')\n\n # check that the uploaded file was added to uploaded files list\n assert api.show_uploads()\n\n # check that our list is not empty\n assert api.file_obj_list","def load_data(self):\n \n # only loader implemented so far !\n try:\n _ascii_array = Utilities.load_ascii(filename=self.filename, sep='')\n start_row = TOF._first_line_number_with_real_data(_ascii_array[0, 0])\n\n _tof_column = _ascii_array[start_row:, 0]\n\n if not TOF._is_this_numeric(_tof_column[0]):\n start_row += 1\n\n _tof_column = _ascii_array[start_row:, 0]\n _counts_column = _ascii_array[start_row:, 1]\n\n self.tof_array = _tof_column\n self.counts_array = _counts_column\n return\n\n except IndexError:\n pass # try another format\n\n try:\n _ascii_array = Utilities.load_ascii(filename=self.filename, sep=',')\n start_row = TOF._first_line_number_with_real_data(_ascii_array[0, 0])\n\n _tof_column = _ascii_array[start_row:, 0] # first row must be excluded in this format\n\n if not TOF._is_this_numeric(_tof_column[0]):\n start_row += 1\n\n _tof_column = _ascii_array[start_row:, 0]\n _counts_column = _ascii_array[start_row:, 1]\n\n self.tof_array = _tof_column\n self.counts_array = _counts_column\n return\n\n except IndexError:\n raise IndexError(\"Format not implemented!\")","def load(self, fname, snver=1):\n self._data = self._io.load(fname, snver=snver)","def __init__(self):\n f = open(configuration.dataDirectory+'Muon_ID_iso_Efficiencies_Run_2012ABCD_53X.pkl', 'r')\n if f :\n self._map = pickle.load(f)\n self._range = ''\n else :\n print 'ERROR: Input file for muon SF not existing!'","def import_equipment_from_file(self, filename='') -> None:\n if not filename:\n filename = cif_file_open_dialog(filter=\"CIF file (*.cif *.cif_od *.cfx)\")\n if not filename:\n print('No file given')\n return\n doc = read_document_from_cif_file(filename)\n if not doc:\n return\n for block in doc:\n self._import_block(block, filename)\n self.show_equipment()","def import_file(self, *args, **kwargs):\n filename = self.file\n self.completed_layers = []\n err = GdalErrorHandler()\n gdal.PushErrorHandler(err.handler)\n gdal.UseExceptions()\n configuration_options = kwargs.get('configuration_options', [{'index': 0}])\n\n # Configuration options should be a list at this point since the importer can process multiple layers in a\n # single import\n if isinstance(configuration_options, dict):\n configuration_options = [configuration_options]\n\n data, inspector = self.open_source_datastore(filename, *args, **kwargs)\n\n datastore_layers = inspector.describe_fields()\n\n if len(datastore_layers) == 0:\n logger.debug('No Dataset found')\n\n layers_info = []\n\n # Add index for any layers configured by name\n for layer_configuration in configuration_options:\n if 'layer_name' in layer_configuration:\n lookup = 'layer_name'\n elif 'index' in layer_configuration:\n lookup = 'index'\n else:\n lookup = None\n logger.debug('could not find lookup')\n continue\n\n for datastore_layer in datastore_layers:\n if datastore_layer.get(lookup) == layer_configuration.get(lookup):\n layer_configuration.update(datastore_layer)\n layers_info.append(layer_configuration)\n\n for layer_options in layers_info:\n if layer_options['raster']:\n \"\"\"\n File is a raster, we need to convert into optimized GeoTiff\n and skip any further testing or loading into target_store\n \"\"\"\n # Increment filename to make sure target doesn't exists\n filedir, filebase = os.path.split(filename)\n outfile = '%s.tif' % os.path.splitext(filebase)[0]\n fileout = increment_filename(os.path.join(RASTER_FILES, outfile))\n raster_import(layer_options['path'], fileout)\n self.completed_layers.append([fileout, layer_options])\n else:\n target_file, _ = self.open_target_datastore(self.target_store)\n target_create_options = []\n\n # Prevent numeric field overflow for shapefiles https://trac.osgeo.org/gdal/ticket/5241\n if target_file.GetDriver().GetName() == 'PostgreSQL':\n target_create_options.append('PRECISION=NO')\n\n layer_options['modified_fields'] = {}\n layer = data.GetLayer(layer_options.get('index'))\n layer_name = layer_options.get('name', layer.GetName().lower())\n layer_type = self.get_layer_type(layer, data)\n srs = layer.GetSpatialRef()\n\n if layer_name.lower() == 'ogrgeojson':\n try:\n layer_name = os.path.splitext(os.path.basename(filename))[0].lower()\n except IndexError:\n pass\n\n layer_name = launder(str(layer_name))\n\n # default the layer to 4326 if a spatial reference is not provided\n if not srs:\n srs = osr.SpatialReference()\n srs.ImportFromEPSG(4326)\n\n # pass the srs authority code to handlers\n if srs.AutoIdentifyEPSG() == 0:\n layer_options['srs'] = '{0}:{1}'.format(srs.GetAuthorityName(None), srs.GetAuthorityCode(None))\n\n n = 0\n while True:\n n += 1\n try:\n target_layer = self.create_target_dataset(target_file, layer_name, srs, layer_type,\n options=target_create_options)\n except RuntimeError as e:\n # logger.exception('exception in creating target dataset')\n # the layer already exists in the target store, increment the name\n if 'Use the layer creation option OVERWRITE=YES to replace it.' in e.message:\n layer_name = increment(layer_name)\n\n # try 100 times to increment then break\n if n >= 100:\n break\n\n continue\n else:\n raise e\n break\n\n # adding fields to new layer\n layer_definition = ogr.Feature(layer.GetLayerDefn())\n source_fid = None\n\n wkb_field = 0\n\n for i in range(layer_definition.GetFieldCount()):\n\n field_def = layer_definition.GetFieldDefnRef(i)\n\n if field_def.GetName() == target_layer.GetFIDColumn() and field_def.GetType() != 0:\n field_def.SetType(0)\n\n if field_def.GetName() != 'wkb_geometry':\n target_layer.CreateField(field_def)\n new_name = target_layer.GetLayerDefn().GetFieldDefn(i - wkb_field).GetName()\n old_name = field_def.GetName()\n\n if new_name != old_name:\n layer_options['modified_fields'][old_name] = new_name\n\n if old_name == target_layer.GetFIDColumn() and not layer.GetFIDColumn():\n source_fid = i\n else:\n wkb_field = 1\n\n if wkb_field is not 0:\n layer.SetIgnoredFields(['wkb_geometry'])\n\n for i in range(0, layer.GetFeatureCount()):\n feature = layer.GetFeature(i)\n\n if feature and feature.geometry():\n\n if not layer.GetFIDColumn():\n feature.SetFID(-1)\n\n if feature.geometry().GetGeometryType() != target_layer.GetGeomType() and \\\n target_layer.GetGeomType() in range(4, 7):\n\n conversion_function = ogr.ForceToMultiPolygon\n\n if target_layer.GetGeomType() == 5:\n conversion_function = ogr.ForceToMultiLineString\n\n elif target_layer.GetGeomType() == 4:\n conversion_function = ogr.ForceToMultiPoint\n\n geom = ogr.CreateGeometryFromWkb(feature.geometry().ExportToWkb())\n feature.SetGeometry(conversion_function(geom))\n\n if source_fid is not None:\n feature.SetFID(feature.GetField(source_fid))\n\n try:\n target_layer.CreateFeature(feature)\n\n except:\n for field in range(0, feature.GetFieldCount()):\n if feature.GetFieldType(field) == ogr.OFTString:\n try:\n feature.GetField(field).decode('utf8')\n except UnicodeDecodeError:\n feature.SetField(field, decode(feature.GetField(field)))\n except AttributeError:\n continue\n try:\n target_layer.CreateFeature(feature)\n except err as e:\n logger.error('Create feature failed: {0}'.format(gdal.GetLastErrorMsg()))\n raise e\n\n self.completed_layers.append([target_layer.GetName(), layer_options])\n\n return self.completed_layers","def load(self,factory={}):\n canSave = self.canSave\n InfoClass = factory.get('INFO',InfoS) #--Info class from factory.\n #--Header\n inPath = os.path.join(self.fileInfo.dir,self.fileInfo.name)\n ins = Tes3Reader(self.fileInfo.name,file(inPath,'rb'))\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\n self.tes3 = Tes3(name,size,delFlag,recFlag,ins,True)\n #--Raw data read\n dial = None\n while not ins.atEnd():\n #--Get record info and handle it\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\n #--DIAL?\n if name == 'DIAL':\n dial = Dial(name,size,delFlag,recFlag,ins,True)\n self.dials.append(dial)\n if canSave: self.records.append(dial)\n #--INFO?\n elif name == 'INFO':\n info = InfoClass(name,size,delFlag,recFlag,ins,True)\n self.records.append(info)\n dial.infos.append(info)\n self.infos[(dial.type,dial.id,info.id)] = info\n #--Non-dials?\n elif canSave:\n record = Record(name,size,delFlag,recFlag,ins)\n self.records.append(record)\n else:\n ins.seek(size,1,'Record')\n #--Done Reading\n ins.close()","def loadFromFile():\n try:\n f1 = open( \"friendshipMap.p\", \"rb\" )\n friendship_map = pickle.load(f1)\n f1.close()\n f2 = open( \"businessReviews.p\", \"rb\" )\n business_reviews = pickle.load(f2)\n f2.close()\n f3 = open( \"degreeCentrality.p\", \"rb\" )\n degree_centrality_map = pickle.load(f3)\n f3.close()\n f4 = open( \"closenessCentrality.p\", \"rb\" )\n closeness_centrality_map = pickle.load(f4)\n f4.close()\n f5 = open( \"betweennessCentrality.p\", \"rb\" )\n betweenness_centrality_map = pickle.load(f5)\n f5.close()\n except IOError as e:\n sys.stderr.write(\"I/O error({0}): {1}\".format(e.errno, e.strerror)+'\\n')\n sys.stderr.write('Try running with -buildClean = clean!\\n')\n\n return (friendship_map, business_reviews, degree_centrality_map, closeness_centrality_map, betweenness_centrality_map, YGraph)","def load_data_part(fname):\n if \"_data\" not in fname:\n return None\n # Read data\n data = pd.read_csv(fname)\n # events file\n events_fname = fname.replace('_data', '_events')\n # read event file\n labels = pd.read_csv(events_fname)\n clean = data.drop(['id'], axis=1) # remove id\n labels = labels.drop(['id'], axis=1) # remove id\n return clean, labels","def load_pfile(self, **kwargs):\r\n pfile = kwargs['pfile']\r\n filetype = kwargs['filetype']\r\n\r\n # Loads the pfile and finds the indices, still need to sync and parse.\r\n self.pfile = PFILE(pfile, filetype=filetype)\r\n # self.pfile.sync(tstep='auto')\r","def __load_model(self):\n loaded = load(self.__file_name)\n self.__model = loaded['model']\n self.__meta_data = loaded['metadata']\n self.__is_ready = True","def load(self, input):\n return","def load(self):\n raise NotImplementedError()","def load(self):\n raise NotImplementedError()","def load(self):\n canSave = self.canSave\n #--Header\n inPath = os.path.join(self.fileInfo.dir,self.fileInfo.name)\n ins = Tes3Reader(self.fileInfo.name,file(inPath,'rb'))\n (name,size,delFlag,recFlag) = ins.unpack('4s3i',16,'REC_HEAD')\n self.tes3 = Tes3(name,size,delFlag,recFlag,ins,True)\n #--Raw data read\n while not ins.atEnd():\n #--Get record info and handle it\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\n #--LEVC?\n if name == 'LEVC':\n levc = Levc(name,size,delFlag,recFlag,ins,True)\n self.levcs[levc.id] = levc\n if canSave: self.records.append(levc)\n #print ' Added:',levc.id\n elif name == 'LEVI':\n levi = Levi(name,size,delFlag,recFlag,ins,True)\n self.levis[levi.id] = levi\n if canSave: self.records.append(levi)\n #print ' Added:',levi.id\n #--Other\n elif canSave:\n record = Record(name,size,delFlag,recFlag,ins)\n self.records.append(record)\n else:\n ins.seek(size,1,'Record')\n #--Done Reading\n ins.close()","def load(path):\n pass","def doImport(self,textFile):\n self.loadText(textFile)\n self.getBooks()\n #self.copyBooks()\n self.genLibData()\n self.genLibCells()\n self.sortRecords()","def load_synthetic_data():\n\n pickle_object = FM().data_file \n\n with pickle_object.open('rb') as data_file: \n return pickle.load(data_file)","def _load(self):\n service_manager = helper_util.getServiceManager(self.hostname, self.port,\n self.uno_path,\n self.office_binary_path)\n desktop = service_manager.createInstance(\"com.sun.star.frame.Desktop\")\n uno_url = self.systemPathToFileUrl(self.document_url)\n uno_document = desktop.loadComponentFromURL(uno_url, \"_blank\", 0, ())\n if not uno_document:\n raise AttributeError(\"This document can not be loaded or is empty\")\n if self.refresh:\n # Before converting to expected format, refresh dynamic\n # value inside document.\n dispatcher = service_manager.createInstance(\"com.sun.star.frame.DispatchHelper\")\n for uno_command in ('UpdateFields', 'UpdateAll', 'UpdateInputFields',\n 'UpdateAllLinks', 'UpdateCharts',):\n dispatcher.executeDispatch(uno_document.getCurrentController().getFrame(),\n '.uno:%s' % uno_command, '', 0, ())\n module_manager = service_manager.createInstance(\"com.sun.star.frame.ModuleManager\")\n self.document_type = module_manager.identify(uno_document)\n self.document_loaded = uno_document","def F(f):\n return datafile(f, __name__)","def load(self):\n settings_path = os.path.join(self.file_path, \"__file_data.json\")\n if os.path.exists( settings_path ):\n self.fileList = simplejson.loads( open( settings_path, 'r' ).read() )\n\n settings_path = os.path.join(self.file_path, \"__user_data.json\")\n if os.path.exists( settings_path ):\n self.userList = simplejson.loads( open( settings_path, 'r' ).read() )","def do_load(self, line):\n cmd_args = io.parse_cmd_args(line, io.load_cmd_pattern)\n if cmd_args:\n success = self.manager.load(**cmd_args)\n if success:\n self.console_print(\"Yippee! load successful!\", settings.INFO_FORMAT)\n else:\n self.console_print(\"Sorry, the data could not be loaded from file.\", settings.ERROR_FORMAT)\n else:\n self.console_print(settings.COMMMAND_ARGS_ERROR_MSG, settings.ERROR_FORMAT)","def read_input():\n\n filenames = sorted(glob.glob(\"%s/openflow_input/*\" % root_dir))\n\n for filename in filenames:\n log(\"Processing struct file: \" + filename)\n ofinput = process_input_file(filename)\n\n # Populate global state\n for wire_version in ofinput.wire_versions:\n version_name = of_g.of_version_wire2name[wire_version]\n versions[version_name]['classes'].update(copy.deepcopy(ofinput.classes))\n of_g.ordered_classes[wire_version].extend(ofinput.ordered_classes)","def load(self, *args, **kwargs):\n pass","def _load(self, file_path, **kwargs):\n raise NotImplementedError()","def LoadBatch(filename):","def load (self, filename) :\n\t\tserialFile = open (filename, \"rb\")\n\t\tself.production_rules = pickle.load (serialFile)\n\t\tself.unitrelation = pickle.load (serialFile)\n\t\tself.labels = pickle.load (serialFile)\n\t\tself.keeper = pickle.load (serialFile)\n\t\tself.strnodes = pickle.load(serialFile)\n\t\tself.tokens = pickle.load (serialFile)\n\t\tserialFile.close()","def __init__(self, filename=None,\n astrotarget=None,data_index=0,\n dataslice0=None,dataslice1=None,\n empty=False, **kwargs):\n self.__build__(data_index=data_index)\n\n if empty:\n return\n \n if filename is not None:\n force_it = kwargs.pop(\"force_it\",True)\n self.load(filename,force_it=force_it,\n dataslice0=dataslice0,\n dataslice1=dataslice1,\n **kwargs)\n # - Set the target if any\n if astrotarget is not None:\n self.set_target(astrotarget)","def load_data(self):\n if self.debug:\n print(\"Loading data\")","def load_data(self, **kwargs):\n type = kwargs['type']\n file = kwargs['file']\n with open(file, 'r') as data_file:\n for line in data_file:\n line = line[:-1]\n items_dict = ast.literal_eval(line)\n\n item = type.from_dict(items_dict)\n\n self.add_item(item, lambda i: i.uid)","def _import(self, datadict):\n self.GUID = datadict.get(\"GUID\", uuid.uuid1())\n self.FileName = datadict.get(\"FileName\", \"\")\n self.Name = datadict.get(\"Name\", \"\")\n self.Projects = datadict.get(\"Projects\", [])\n self.VSVersion = datadict.get(\"VSVersion\", None)","def load_object(fpath):\r\n with open(fpath, 'rb') as i:\r\n return pickle.load(i)","def load_aif(\n obj: aif.Graph,\n name: t.Optional[str] = None,\n config: Config = DefaultConfig,\n) -> Graph:\n g = config.GraphClass(name)\n\n for aif_node in obj[\"nodes\"]:\n node = (\n atom_from_aif(aif_node, config)\n if aif_node[\"type\"] == \"I\"\n else scheme_from_aif(aif_node, config)\n )\n\n if node:\n g.add_node(node)\n\n for aif_edge in obj[\"edges\"]:\n if edge := edge_from_aif(aif_edge, g.nodes, config):\n g.add_edge(edge)\n\n return g","def __init__(self):\n f = open(configuration.dataDirectory+'MuonEfficiencies_Run_2012A_2012_B_53X.pkl', 'r')\n if f :\n self._map = pickle.load(f)\n self._eta_range = ''\n self._pt_range = ''\n else :\n print 'ERROR: Input file for Trigger efficiencies not existing!'","def __init__(self):\n f = open(configuration.dataDirectory+'MuonEfficiencies_Run_2012A_2012_B_53X.pkl', 'r')\n if f :\n self._map = pickle.load(f)\n self._eta_range = ''\n self._pt_range = ''\n else :\n print 'ERROR: Input file for Trigger efficiencies not existing!'","def load(logFile):\n pass #TODO","def _read_file(self):\n\n with open(self.file_name, 'rb') as f:\n new_test = struct.unpack('<l', f.read(8)[4:])[0]\n f.close()\n\n with open(self.file_name, 'rb') as f:\n old_test = struct.unpack('<h', f.read(6)[4:])[0]\n f.close()\n\n with open(self.file_name, 'rb') as f:\n other_test = struct.unpack('<l', f.read(20)[16:])[0]\n f.close()\n\n open_file = open(self.file_name, 'rb')\n\n if (other_test==202):\n raw = open_file.read(1236)[11:]\n self.model = '202'\n elif ((not new_test==102) and old_test==102):\n raw = open_file.read(1133)\n self.model = '102old'\n elif (new_test==102 and old_test==102):\n raw = open_file.read(1224)\n self.model = '102new'\n\n self.header = DpHeader(raw, self.model)\n\n self.data = DpData(open_file, \n self.model, \n self.header.interferogram_size, \n self.header.number_of_coadds, \n 2048*self.header.zero_fill,\n self.header.laser_wavelength_microns, \n self.header.dispersion_constant_xm,\n self.header.dispersion_constant_xb)\n\n open_file.close()"],"string":"[\n \"def load_data(self) -> None:\",\n \"def _load(self):\\n op_type_file_path = os.path.join(\\n self._profiling_dir,\\n self._csv_file_to_analyse.format(self._device_id)\\n )\\n op_type_file_path = validate_and_normalize_path(\\n op_type_file_path, raise_key=\\\"Invalid op_type_file_path\\\")\\n if not os.path.isfile(op_type_file_path):\\n log.warning('The file <%s> does not exist.', op_type_file_path)\\n return\\n\\n with open(op_type_file_path, 'r') as file:\\n csv_reader = csv.reader(file)\\n _ = next(csv_reader)\\n for info in csv_reader:\\n self._data.append(self._convert_field_type(info))\",\n \"def init_from_file(self):\\n self.src.load('start.00') \\n self.oe1.load('start.01')\\n #self.det.load('start.02')\\n print('NOTE: variables loaded from start.00/start.01 files')\",\n \"def load_data(self):\",\n \"def load_data(self):\\n self.tif_file = self._find_tif_file()\\n if self.with_labeling is not None:\\n self.colabel_file = self._find_colabeled_file()\\n self.colabel_stack = self._load_colabeled_img()\\n self.dff, self.indices = self._populate_dff_data()\\n self.loaded = True\",\n \"def load(self, filename):\\n pass\",\n \"def load(cls, from_file):\\n raise NotImplementedError\",\n \"def load_file(path, data_type=None, *args, **kwargs):\\n\\n path = os.path.normpath(path)\\n if os.path.isdir(path) and path[-1] != os.sep:\\n path = path + os.sep\\n\\n if data_type == None:\\n data_type = autodetect(path)\\n\\n if data_type == \\\"prospa\\\":\\n return dnpIO.prospa.import_prospa(path, *args, **kwargs)\\n\\n elif data_type == \\\"topspin\\\":\\n return dnpIO.topspin.import_topspin(path, *args, **kwargs)\\n\\n elif data_type == \\\"topspin dir\\\":\\n return dnpIO.topspin.import_topspin_dir(path, *args, **kwargs)\\n\\n elif data_type == \\\"delta\\\":\\n return dnpIO.delta.import_delta(path, *args, **kwargs)\\n\\n elif data_type == \\\"vnmrj\\\":\\n return dnpIO.vnmrj.import_vnmrj(path, *args, **kwargs)\\n\\n elif data_type == \\\"tnmr\\\":\\n return dnpIO.tnmr.import_tnmr(path, *args, **kwargs)\\n\\n elif data_type == \\\"specman\\\":\\n return dnpIO.specman.import_specman(path, *args, **kwargs)\\n\\n elif data_type == \\\"xepr\\\" or data_type == \\\"xenon\\\":\\n return dnpIO.bes3t.import_bes3t(path, *args, **kwargs)\\n\\n elif data_type == \\\"winepr\\\" or data_type == \\\"esp\\\":\\n return dnpIO.winepr.import_winepr(path, *args, **kwargs)\\n\\n elif data_type == \\\"h5\\\":\\n return dnpIO.h5.load_h5(path, *args, **kwargs)\\n\\n elif data_type == \\\"power\\\":\\n return dnpIO.power.importPower(path, *args, **kwargs)\\n\\n elif data_type == \\\"vna\\\":\\n return dnpIO.vna.import_vna(path, *args, **kwargs)\\n\\n elif data_type == \\\"cnsi_powers\\\":\\n return dnpIO.cnsi.get_powers(path, *args, **kwargs)\\n\\n else:\\n raise ValueError(\\\"Invalid data type: %s\\\" % data_type)\",\n \"def load(f: Union[str, os.PathLike], model):\\n from ..utils.flopy_io import multi_line_strip\\n\\n pkg_ws = os.path.split(f)[0]\\n with open(f) as foo:\\n t = [0]\\n while t[0] != \\\"ncells\\\":\\n t = multi_line_strip(foo).split()\\n\\n ncells = int(t[1])\\n\\n t = [0]\\n while t[0] != \\\"izone\\\":\\n t = multi_line_strip(foo).split()\\n\\n method = multi_line_strip(foo).split()[0]\\n\\n if method in (\\\"internal\\\", \\\"open/close\\\"):\\n izone = np.zeros((ncells,), dtype=int)\\n i = 0\\n fobj = foo\\n if method == \\\"open/close\\\":\\n fobj = open(os.path.join(pkg_ws, t[1]))\\n while i < ncells:\\n t = multi_line_strip(fobj)\\n if t[0] == \\\"open/close\\\":\\n if fobj != foo:\\n fobj.close()\\n fobj = open(os.path.join(pkg_ws, t[1]))\\n for zn in t:\\n izone[i] = zn\\n i += 1\\n else:\\n izone = np.array([t[1]] * ncells, dtype=int)\\n\\n zon = ZoneFile6(model, izone)\\n return zon\",\n \"def load(self, file_id):\\n pass\",\n \"def load(self):\\r\\n self.read(self.filename)\",\n \"def _load_data() -> UpliftData:\\n with project_dir(\\\"axinova\\\"):\\n data = UpliftData(\\n ax_data=load_bin(\\\"ax_data.feather\\\"),\\n ax_var_struct=load_bin(\\\"ax_var_struct.feather\\\"),\\n population_codes=load_pickle(\\\"population_ratios.pkl\\\"),\\n global_codes=load_pickle(\\\"global_code_ratios.pkl\\\"),\\n station_codes=load_pickle(\\\"station_code_ratios.pkl\\\"),\\n spr_data=load_pickle(\\\"spr_data.pkl\\\"),\\n )\\n data.all_stations = data.ax_data[\\\"Station\\\"].cat.categories.to_list()\\n data.all_weekdays = data.ax_data[\\\"DayOfWeek\\\"].cat.categories.to_list()\\n data.all_timescales = [\\\"Time\\\", \\\"ShortTime\\\", \\\"Hour\\\", \\\"TimeSlot\\\"]\\n data.var_info = {}\\n for (var_id, struct) in data.ax_var_struct.groupby(\\\"Variable\\\"):\\n data.var_info[var_id] = dict(\\n Label=struct[\\\"Variable_Label\\\"].max(),\\n Codes=struct[\\\"Label\\\"].to_list(),\\n Order=list(range(len(struct[\\\"Label_Nr\\\"].to_list()))),\\n )\\n data.combi_var = {\\n \\\"md_SexAgeEk\\\": (\\n data.variable_table(\\\"md_SexAgeEk\\\")\\n .iloc[:, 0]\\n .str.split(\\\"/ \\\", expand=True)\\n .rename(columns={0: \\\"md_sex\\\", 1: \\\"md_agenatrep\\\", 2: \\\"md_ek\\\"})\\n )\\n }\\n return data\",\n \"def open_from(self, f: BinaryIO):\\n raise NotImplementedError\",\n \"def _load_file(self):\\n getLogger(__name__).debug(\\\"Loading {} in {} mode.\\\".format(self.filename, self.mode))\\n try:\\n kwargs = {'driver': 'H5FD_CORE'} if self.in_memory else {}\\n self.file = tables.open_file(self.filename, mode='a' if self.mode == 'write' else 'r', **kwargs)\\n except (IOError, OSError):\\n raise\\n\\n # get important cal params\\n self.nominal_wavelength_bins = self.nyquist_wavelengths()\\n\\n # get the beam image\\n self.beamImage = self.file.get_node('/beammap/map').read()\\n self._flagArray = self.file.get_node('/beammap/flag') # The absence of .read() here is correct\\n self.nXPix, self.nYPix = self.beamImage.shape\\n\\n # get the photontable\\n self.photonTable = self.file.get_node('/photons/photontable')\",\n \"def load(self, filename):\\n raise NotImplementedError\",\n \"def load_data(self):\\n raise NotImplementedError()\",\n \"def load_data():\\r\\n print ('Loadng all the file one time......')\\r\\n if not os.path.exists('cifar.pkl'):\\r\\n set_data()\\r\\n with open('cifar.pkl', 'rb') as cifar_pickle:\\r\\n data = six.moves.cPickle.load(cifar_pickle)\\r\\n return data\",\n \"def load_file():\\n global list_of_table, data_base, new_data\\n open_name = askopenfilename()\\n\\n if Path(open_name).suffix == '.db':\\n data_base = open_name\\n data_base = str(data_base)\\n new_data_base = parse(data_base)\\n new_data = update_list_tables(new_data_base)\\n new_data.clear()\\n\\n else:\\n mistake_db_file()\",\n \"def load(self, ocadfile=None):\\n if ocadfile:\\n (ocadName, ext) = os.path.splitext(ocadfile)\\n self.ocadName = ocadName\\n else:\\n raise OcadfileException(\\\"File not specified!\\\")\\n \\n try:\\n self.__open()\\n self.block = None\\n self.syhdr = None\\n self.StringsStorage = None\\n \\n if self.ocad:\\n self.__ocadHeader()\\n self.__symbolsHeader() # Version <= 8\\n self.__setup() # Version <= 8\\n \\n finally: \\n self.__close()\",\n \"def load_file(*args, **kwargs): # real signature unknown\\n pass\",\n \"def load(self) -> None:\\n self._load_data()\\n self._load_poses()\\n self._load_timestamps()\",\n \"def load(self, filename=None):\\n importer = aspecd.io.AdfImporter()\\n importer.source = filename\\n importer.import_into(self)\",\n \"def load(self):\\n\\n raise NotImplementedError\",\n \"def load(self, input):\",\n \"def load(self):\",\n \"def loadData(self, file):\\n self.data = batchImport(file, self.ps)\",\n \"def load(self):\\n pass\",\n \"def load(self):\\n pass\",\n \"def load(self):\\n pass\",\n \"def load(self):\\n pass\",\n \"def load(self, input):\\n pass\",\n \"def load_test_file():\\n hou.hipFile.load(\\n os.path.join(\\n os.path.dirname(os.path.abspath(__file__)),\\n \\\"data\\\",\\n \\\"test_api_integration.hipnc\\\",\\n ),\\n ignore_load_warnings=True,\\n )\\n\\n yield\\n\\n hou.hipFile.clear()\",\n \"def _read(self):\\n # initializng data dictionary\\n self.data={}\\n\\n f = FortranFile(self.filename)\\n # Default omnivor binary header\\n self.data['MK'] = f.readInts('i')\\n self.data['itime'] = f.readInts('i')\\n self.data['version'] = f.readString()\\n self.data['file_id'] = f.readInts('i')\\n self.data['sversion'] = f.readString()\\n # Velocity field\\n self.data['stype'] = f.readString()\\n self.data['is_grid'] = f.readInts('i')\\n nCPs = f.readInts('i')\\n self.data['nCPs'] = nCPs\\n if self.data['MK'] == 8:\\n real_char='d'\\n else:\\n real_char='f'\\n if self.data['is_grid']:\\n #print('File is a velocity grid file')\\n n1 = f.readInts('i')\\n n2 = f.readInts('i')\\n n3 = f.readInts('i')\\n self.data['n1'] = n1\\n self.data['n2'] = n2\\n self.data['n3'] = n3\\n self.data['is_straight'] = f.readInts('i')\\n self.data['v1'] = f.readReals(real_char)\\n self.data['v2'] = f.readReals(real_char)\\n self.data['v3'] = f.readReals(real_char)\\n\\n CPs_raw = f.readReals(real_char)\\n Utot_raw = f.readReals(real_char)\\n CPs = np.reshape(CPs_raw,(3,nCPs),order = 'F')\\n Utot = np.reshape(Utot_raw,(3,nCPs),order = 'F')\\n\\n acc=-1\\n CPsTab = np.zeros((3, n1,n2,n3))\\n UtotTab = np.zeros((3, n1,n2,n3))\\n # Reshaping the nasty way (this is natural order). \\n for i in range(0,n1):\\n for j in range(0,n2):\\n for k in range(0,n3):\\n acc=acc+1\\n CPsTab[0:3,i,j,k] = CPs[0:3,acc]\\n UtotTab[0:3,i,j,k] = Utot[0:3,acc]\\n\\n self.data['CPs'] = CPs\\n self.data['CPsTab'] = CPsTab\\n self.data['Utot'] = Utot\\n self.data['UtotTab'] = UtotTab\",\n \"def load_all_data_from_file(self) -> None:\\n self.load_gene_data_from_file()\\n self.load_ontology_from_file(ontology_type=DataType.GO, ontology_url=self.go_ontology_url,\\n ontology_cache_path=self.go_ontology_cache_path,\\n config=self.config)\\n self.load_associations_from_file(associations_type=DataType.GO, associations_url=self.go_associations_url,\\n associations_cache_path=self.go_associations_cache_path, config=self.config)\\n self.load_ontology_from_file(ontology_type=DataType.DO, ontology_url=self.do_ontology_url,\\n ontology_cache_path=self.do_ontology_cache_path, config=self.config)\\n self.load_associations_from_file(associations_type=DataType.DO, associations_url=self.do_associations_url,\\n associations_cache_path=self.do_associations_cache_path,\\n association_additional_cache_path=self.do_associations_new_cache_path,\\n association_additional_url=self.do_associations_new_url, config=self.config)\\n self.load_ontology_from_file(ontology_type=DataType.EXPR, ontology_url=self.expression_ontology_url,\\n ontology_cache_path=self.expression_ontology_cache_path, config=self.config)\\n self.load_associations_from_file(associations_type=DataType.EXPR,\\n associations_url=self.expression_associations_url,\\n associations_cache_path=self.expression_associations_cache_path,\\n config=self.config)\\n self.load_orthology_from_file()\\n self.load_expression_cluster_data()\\n self.load_protein_domain_information()\",\n \"def load_model(self, filename):\\r\\n pass\",\n \"def test1_loading(self):\\n\\t\\tprint \\\"\\\\nTEST 1: Loading ontologies from %s folder.\\\\n=================\\\" % DATA_FOLDER\\n\\t\\t\\n\\t\\tfor f in os.listdir(DATA_FOLDER):\\n\\t\\t\\tif not f.startswith('.'):\\n\\t\\t\\t\\tprint \\\"Loading... >\\\", f\\t\\t\\n\\t\\t\\t\\t\\n\\t\\t\\t\\to = ontospy.Ontology(DATA_FOLDER + f)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tself.assertEqual(type(o), ontospy.Ontology)\\n\\t\\t\\t\\tprint \\\"Success.\\\"\",\n \"def get_model_data_from_files(self, oc):\\r\\n # Load model related files\\r\\n model_path = self.config['DATA_PATH'] + self.config['CUSTOMER_NAME'] + '/models/'\\r\\n\\r\\n features_file = model_path + self.task + '_' + str(oc) + '_features.txt'\\r\\n dummies_file = model_path + self.task + '_' + str(oc) + '_dummies.txt'\\r\\n model_file = model_path + self.task + '_' + str(oc) + '.joblib'\\r\\n\\r\\n if os.path.isfile(features_file) and os.path.isfile(dummies_file) and os.path.isfile(model_file):\\r\\n model = joblib.load(model_file)\\r\\n features = open(features_file, 'r', encoding=self.config['DATA_ENCODING']).read().rstrip('\\\\n').split(self.config['DATA_SEPARATOR'])\\r\\n dummies = open(dummies_file, 'r', encoding=self.config['DATA_ENCODING']).read().rstrip('\\\\n').split(self.config['DATA_SEPARATOR'])\\r\\n return (model, features, dummies)\\r\\n return (None, None, None)\",\n \"def dataLoad():\\n try:\\n try: #Python3\\n f = open(__file__ + \\\".csv\\\",\\\"rt\\\")\\n except: #Python2\\n f = open(__file__ + \\\".csv\\\",\\\"rb\\\")\\n data = f.read().split(',')\\n entryCol.entry0.delete(0,END)\\n entryCol.entry0.insert(0,data[0])\\n entryCol.entry1.delete(0,END)\\n entryCol.entry1.insert(0,data[1])\\n entryCol.entry2.delete(0,END)\\n entryCol.entry2.insert(0,data[2])\\n entryCol.entry3.delete(0,END)\\n entryCol.entry3.insert(0,data[3])\\n botWind.writeN(\\\"DataLoad: File\\\")\\n except:\\n botWind.writeN(\\\"DataLoad: Default\\\")\",\n \"def _load_obcfile(casename=None): \\n\\n data={}\\n\\n if casename==None:\\n print('_load_obcfile requires a filename to load.')\\n return\\n try:\\n fp=open(casename+'_obc.dat','r')\\n except IOError:\\n print('_load_obcfile: invalid case name.')\\n return data\\n\\n obc_str=fp.readline().split('=')\\n obc_num=int(obc_str[1])\\n t_data1=np.genfromtxt(casename+'_obc.dat',skip_header=1)\\n fp.close()\\n\\n data['obcf_num']=obc_num\\n data['obcf_numbers']=t_data1[:,0]\\n data['obcf_nodes']=t_data1[:,1]\\n data['obcf_value']=t_data1[:,2]\\n\\n \\n return data\",\n \"def load(self):\\n raise NotImplementedError\",\n \"def load(self):\\n raise NotImplementedError\",\n \"def read_data(feature_file, label_file):\",\n \"def load(cls, f, model, ext_unit_dict=None):\\n msg = (\\n \\\"Model object must be of type flopy.mfusg.MfUsg\\\\n\\\"\\n f\\\"but received type: {type(model)}.\\\"\\n )\\n assert isinstance(model, MfUsg), msg\\n\\n if model.verbose:\\n print(\\\"loading bcf package file...\\\")\\n\\n f_obj = get_open_file_object(f, \\\"r\\\")\\n\\n # dataset 0 -- header\\n while True:\\n line = f_obj.readline()\\n if line[0] != \\\"#\\\":\\n break\\n\\n # determine problem dimensions\\n nlay = model.nlay\\n dis = model.get_package(\\\"DIS\\\")\\n if dis is None:\\n dis = model.get_package(\\\"DISU\\\")\\n njag = dis.njag\\n\\n # Item 1: ipakcb, HDRY, IWDFLG, WETFCT, IWETIT, IHDWET - line already read above\\n if model.verbose:\\n print(\\\" loading ipakcb, HDRY, IWDFLG, WETFCT, IWETIT, IHDWET...\\\")\\n text_list = line_parse(line)\\n ipakcb, hdry, iwdflg, wetfct, iwetit, ihdwet = (\\n int(text_list[0]),\\n float(text_list[1]),\\n int(text_list[2]),\\n float(text_list[3]),\\n int(text_list[4]),\\n int(text_list[5]),\\n )\\n\\n ikvflag = type_from_iterable(\\n text_list, index=6, _type=int, default_val=0\\n )\\n ikcflag = type_from_iterable(\\n text_list, index=7, _type=int, default_val=0\\n )\\n\\n # LAYCON array\\n laycon, intercellt = cls._load_laycon(f_obj, model)\\n\\n # TRPY array\\n if model.verbose:\\n print(\\\" loading TRPY...\\\")\\n trpy = Util2d.load(\\n f_obj, model, (nlay,), np.float32, \\\"trpy\\\", ext_unit_dict\\n )\\n\\n # property data for each layer based on options\\n transient = not dis.steady.all()\\n anis = any(t != 1 for t in trpy)\\n anglex = 0\\n if (not model.structured) and anis:\\n if model.verbose:\\n print(\\\"loading ANGLEX...\\\")\\n anglex = Util2d.load(\\n f_obj, model, (njag,), np.float32, \\\"anglex\\\", ext_unit_dict\\n )\\n\\n # hy, kv, storage\\n (sf1, tran, hy, vcont, sf2, wetdry, kv) = cls._load_layer_arrays(\\n f_obj,\\n model,\\n nlay,\\n ext_unit_dict,\\n transient,\\n laycon,\\n ikvflag,\\n ikcflag,\\n iwdflg,\\n )\\n\\n # Ksat mfusg\\n ksat = 0\\n if (not model.structured) and abs(ikcflag == 1):\\n if model.verbose:\\n print(\\\" loading ksat (njag)...\\\")\\n ksat = Util2d.load(\\n f_obj, model, (njag,), np.float32, \\\"ksat\\\", ext_unit_dict\\n )\\n\\n f_obj.close()\\n\\n # set package unit number\\n unitnumber, filenames = get_unitnumber_from_ext_unit_dict(\\n model, cls, ext_unit_dict, ipakcb\\n )\\n\\n # create instance of bcf object\\n bcf = cls(\\n model,\\n ipakcb=ipakcb,\\n intercellt=intercellt,\\n laycon=laycon,\\n trpy=trpy,\\n hdry=hdry,\\n iwdflg=iwdflg,\\n wetfct=wetfct,\\n iwetit=iwetit,\\n ihdwet=ihdwet,\\n ikvflag=ikvflag,\\n ikcflag=ikcflag,\\n tran=tran,\\n hy=hy,\\n vcont=vcont,\\n kv=kv,\\n anglex=anglex,\\n ksat=ksat,\\n sf1=sf1,\\n sf2=sf2,\\n wetdry=wetdry,\\n unitnumber=unitnumber,\\n filenames=filenames,\\n )\\n\\n # return bcf object\\n return bcf\",\n \"def _load(self):\\n if self.file_path.exists():\\n with open(self.file_path) as fid:\\n self.data = json.load(fid)\",\n \"def _load(self):\\n raise NotImplementedError()\",\n \"def Load(self):\\n\\t\\tfile = open(self.fileName, 'r')\\n\\t\\tself.hdr = file.readline().split('\\\\n')[0].split(',')\\n\\t\\t\\n\\t\\tfor line in file.readlines():\\n\\t\\t\\ttokens = line.split('\\\\n')[0].split(',')\\n\\t\\t\\tif int(tokens[1]) == 0:\\n\\t\\t\\t\\tself.h0.append(tokens[0])\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.h1.append(tokens[0])\\n\\t\\tfile.close()\\n\\t\\tself.numH1 = len(self.h1)\\n\\t\\tself.numH0 = len(self.h0)\",\n \"def load_model_file(device_index):\\n print(\\\"\\\\nStart loading model...\\\")\\n\\n return kdp_wrapper.isi_load_nef(device_index, MODEL_FILE, ISI_APP_ID)\",\n \"def load(self):\\n #print self.fileInfo.name\\n progress = self.progress\\n filePath = os.path.join(self.fileInfo.dir,self.fileInfo.name)\\n self.fileSize = os.path.getsize(filePath)\\n #--Localize\\n cells = self.cells\\n records = self.records\\n canSave = self.canSave\\n skipObjRecords = self.skipObjRecords\\n contTypes = set(['CREC','CNTC','NPCC'])\\n levTypes = set(('LEVC','LEVI'))\\n debrisIds = self.debrisIds\\n debrisTypes = set(debrisIds.keys())\\n #--Header\\n inPath = os.path.join(self.fileInfo.dir,self.fileInfo.name)\\n ins = Tes3Reader(self.fileInfo.name,file(inPath,'rb'))\\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\\n self.tes3 = Tes3(name,size,delFlag,recFlag,ins,True)\\n if not canSave: del self.tes3.others[:]\\n #--Progress info\\n progress = self.progress\\n progress(0.0,'Loading '+self.fileInfo.name)\\n #--Raw data read\\n while not ins.atEnd():\\n #--Get record info and handle it\\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\\n #print \\\"%s [%d]\\\" % (name,size)\\n #--CELL?\\n if name == 'CELL':\\n record = Cell(name,size,delFlag,recFlag,ins,0,skipObjRecords)\\n cells.append(record)\\n if canSave: records.append(record)\\n #--Contents\\n elif canSave and name in contTypes:\\n if name == 'CREC':\\n record = Crec(name,size,delFlag,recFlag,ins,True)\\n elif name == 'CNTC':\\n record = Cntc(name,size,delFlag,recFlag,ins,True)\\n else:\\n record = Npcc(name,size,delFlag,recFlag,ins,True)\\n self.conts.append(record)\\n self.conts_id[record.getId()] = record\\n records.append(record)\\n #--File Map\\n elif name == 'FMAP':\\n record = Fmap(name,size,delFlag,recFlag,ins)\\n self.fmap = record\\n records.append(record)\\n #--Landscapes\\n elif name == 'LAND':\\n record = Land(name,size,delFlag,recFlag,ins)\\n self.lands[record.getId()] = record\\n records.append(record)\\n #--Scripts\\n elif canSave and name == 'SCPT':\\n record = Scpt(name,size,delFlag,recFlag,ins,True)\\n records.append(record)\\n if record.getRef():\\n self.refs_scpt[record] = record.getRef()\\n #--Save debris info?\\n elif name in debrisTypes:\\n record = Record(name,size,delFlag,recFlag,ins)\\n id = record.getId()\\n if id:\\n debrisIds[name].append(id.lower())\\n if canSave:\\n records.append(record)\\n #--Skip Non-cell?\\n elif not canSave:\\n ins.seek(size,1,name)\\n #--Keep non-cell?\\n else:\\n records.append(Record(name,size,delFlag,recFlag,ins))\\n #--Done Reading\\n ins.close()\\n #--Analyze Cells\\n cntCells = 0\\n progress.setMax(len(self.cells))\\n for cell in self.cells:\\n cell.load(None,1)\\n self.cells_id[cell.getId()] = cell\\n if not canSave:\\n cell.data = None #--Free some memory\\n #--Progress\\n cntCells += 1\\n progress(cntCells)\\n #--Scripts\\n if self.refs_scpt:\\n self.updateScptRefs()\",\n \"def import_data_helper(self): \\n if len(self.components) == 1:\\n hapi.fetch(TableName = self.tablename, M = self.components[0][0], I = self.components[0][1], numin = self.min_x, numax = self.max_x)\\n else: \\n global_id = []\\n for c in self.components:\\n global_id.append(hapi.ISO[c][0])\\n hapi.fetch_by_ids(TableName = self.tablename, iso_id_list = global_id, numin = self.min_x, numax = self.max_x)\",\n \"def load(file_name):\\n ferme_fenetre()\\n Hitori(file_name)\",\n \"def load_binary_data(self, encoding='utf8'):\\n\\n # TODO use smart_open again when https://github.com/RaRe-Technologies/smart_open/issues/207 will be fixed\\n with open(self.file_name, 'rb') as f:\\n self.load_model_params(f)\\n self.load_dict(f, encoding=encoding)\\n self.load_vectors(f)\",\n \"def loaditems(self, fh):\\n pass\",\n \"def main():\\n print \\\"=\\\" * 78\\n print \\\"%s %s\\\" % (__prog_name__, __version__)\\n debug, input_file_names = check_cli()\\n if not input_file_names:\\n _error(\\\"No input file name found!\\\\n\\\\n%s\\\" % __help__)\\n for input_file_name in input_file_names:\\n print \\\"* Reading\\\", input_file_name\\n file_base_name = os.path.splitext(os.path.basename(input_file_name))[0]\\n file_dir_name = os.path.dirname(input_file_name)\\n sections = {}\\n tex_map = {}\\n with open(input_file_name, 'rU') as in_fd:\\n sections = get_sections(in_fd.read())\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"sec\\\",\\n {\\\"sections\\\": sections})\\n\\n if not sections:\\n _error(\\\"Nothing could be read from '%s'.\\\\nIs this an Oolite .dat file?\\\" \\\\\\n % input_file_name)\\n\\n # Magically call the 'check' functions\\n for name in sections.keys():\\n f_name = \\\"check_%s\\\" % name.lower()\\n if f_name in globals().keys():\\n if not globals()[f_name](sections):\\n _error(\\\"Number of entries in '%s' section is different as declared!\\\" % name)\\n\\n def get_data(name, sections=sections):\\n \\\"\\\"\\\"Returns the 'data' object from the 'name' one found in the\\n 'sections' one.\\n :sections: dictionary: Object returned by 'get_sections'.\\n :name: string: The name of the section to get the 'data'.\\n Returns a list of 'lines'.\\n \\\"\\\"\\\"\\n return sections.get(name, {}).get(\\\"data\\\", [])\\n\\n oti_file_name = build_file_path(file_dir_name, file_base_name, \\\"oti\\\")\\n tex_map = parse_names(get_data(\\\"NAMES\\\"), oti_file_name)\\n\\n tex_refs, tex_lines_out = parse_textures(get_data(\\\"TEXTURES\\\"))\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"tex\\\",\\n {\\\"tex_refs\\\": tex_refs,\\n \\\"tex_lines_out\\\": tex_lines_out})\\n\\n # Update the tex_map object if textures indexes and names are both\\n # used in 'TEXTURES'.\\n if sorted(tex_map.keys()) != sorted(tex_refs.get(\\\"named\\\").keys()):\\n tex_map = update_tex_map(tex_map,\\n set(tex_refs[\\\"named\\\"].keys()).difference(tex_map.keys()))\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"txm\\\",\\n {\\\"tex_map\\\": tex_map})\\n\\n n_verts, vertex_lines_out = parse_vertex(get_data(\\\"VERTEX\\\"))\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"ver\\\",\\n {\\\"n_verts\\\": n_verts,\\n \\\"vertex_lines_out\\\": vertex_lines_out})\\n\\n n_normals, normals_lines_out = parse_normals(get_data(\\\"NORMALS\\\"))\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"nor\\\",\\n {\\\"n_normals\\\": n_normals,\\n \\\"normals_lines_out\\\": normals_lines_out})\\n\\n n_faces, faces_groups = parse_faces(get_data(\\\"FACES\\\"), tex_refs,\\n normals_lines_out)\\n\\n if debug:\\n write_dump_file(file_dir_name, file_base_name, \\\"fac\\\",\\n {\\\"n_faces\\\": n_faces,\\n \\\"faces_groups\\\": faces_groups})\\n\\n output_file_name = build_file_path(file_dir_name,\\n file_base_name, 'obj')\\n material_file_name = build_file_path(file_dir_name,\\n file_base_name, 'mtl')\\n mtl_lib_file = os.path.basename(material_file_name)\\n\\n write_obj(output_file_name, file_base_name, mtl_lib_file,\\n tex_lines_out, tex_map, n_verts, vertex_lines_out,\\n n_normals, normals_lines_out, n_faces, faces_groups)\\n\\n write_mtl(material_file_name, tex_map)\\n\\n _exit(\\\"* Done\\\")\",\n \"def loadIni(self):\\n reLoadFiles = re.compile(r'^\\\\[Game Files\\\\](.*)')\\n reLoadFile = re.compile(r'GameFile[0-9]+=(.*)$')\\n #--Read file\\n self.mtime = getmtime(self.path)\\n self.size = os.path.getsize(self.path)\\n ins = file(self.path,'rt')\\n #--Pre-Load Lines\\n del self.preLoadLines[:]\\n del self.postLoadLines[:]\\n while True:\\n line = ins.readline()\\n if not line: \\n ins.close()\\n raise Tes3Error('Morrowind.ini', _('Morrowind.ini: [GameFiles] section not found.'))\\n maLoadFiles = reLoadFiles.match(line)\\n if maLoadFiles: break\\n self.preLoadLines.append(line)\\n #--Load Files \\n self.loadFilesComment = maLoadFiles.group(1)\\n del self.loadFiles[:]\\n del self.loadFilesBad[:]\\n while True:\\n line = ins.readline()\\n maLoadFile = reLoadFile.match(line)\\n if not maLoadFile: \\n if line: self.postLoadLines.append(line)\\n break\\n loadFile = unicode(maLoadFile.group(1), 'latin-1')\\n loadPath = os.path.join(self.dir,'Data Files',loadFile)\\n loadExt = os.path.splitext(loadPath)[-1].lower()\\n if len(self.loadFiles) == 255:\\n self.loadFilesExtra.append(loadFile)\\n elif os.path.exists(loadPath) and re.match('^\\\\.es[pm]$',loadExt):\\n self.loadFiles.append(loadFile)\\n else:\\n self.loadFilesBad.append(loadFile)\\n #--Post-Load Lines\\n while True:\\n line = ins.readline()\\n if not line: break\\n self.postLoadLines.append(line)\\n #--Done\\n ins.close()\",\n \"def load(self,filename=None): # return True\\r\\n pass\",\n \"def _load(self):\\n\\n # number of non-data header details at top of data file\\n header = 1\\n\\n # open file\\n weatherData = []\\n with open(self.wfile) as myfile:\\n if (self.lines > 0):\\n weatherData = [next(myfile) for x in xrange(self.lines + header)]\\n else:\\n weatherData = myfile.readlines()\\n\\n # get data stream from first line\\n streamHeader = weatherData.pop(0).rstrip()\\n if (streamHeader == 'FULL'):\\n self.dataStream = 0\\n elif (streamHeader == 'ADVANCED'):\\n self.dataStream = 1\\n elif (streamHeader == 'BASIC'):\\n self.dataStream = 2\\n else:\\n print \\\"Error: unecognised data stream from file %s\\\" % (self.wfile)\\n return -1\\n\\n # read data\\n inputData = []\\n for line in weatherData:\\n entries = line.split()\\n inputData.append(entries)\\n\\n # copy all into np array\\n self.data = np.array(inputData)\\n\\n return 0\",\n \"def load_data():\\r\\n global labelNames\\r\\n print(\\\"Loading Data...\\\")\\r\\n\\r\\n fnpath = \\\"rawdata\\\\\\\\cifar-10-batches-py\\\"\\r\\n fnprefix = 'data_batch_'\\r\\n fnlblnames = 'batches.meta'\\r\\n fntstbatch = 'test_batch'\\r\\n\\r\\n labelNames = unpickle(path.join(fnpath, fnlblnames))\\r\\n label_names = []\\r\\n for label in labelNames['label_names']:\\r\\n label_names.append(\\\"\\\".join(map(chr, label)))\\r\\n labelNames['label_names'] = label_names\\r\\n\\r\\n CIFAR_Data.append(unpickle(path.join(fnpath, fntstbatch)))\\r\\n for n in range(1, 6):\\r\\n CIFAR_Data.append(unpickle(path.join(fnpath, fnprefix + str(n))))\",\n \"def load(fnames, tag='', inst_id=''):\\n\\n # Save each file to the output DataFrame\\n data = load_csv_data(fnames, read_csv_kwargs={'index_col': 0,\\n 'parse_dates': True})\\n\\n # Assign the meta data\\n meta, status_desc = mm_ace.common_metadata()\\n flux_desc = '5-min averaged Differential '\\n\\n meta['status_e'] = {meta.labels.units: '',\\n meta.labels.name: 'Diff e- Flux Status',\\n meta.labels.notes: '',\\n meta.labels.desc: status_desc,\\n meta.labels.fill_val: np.nan,\\n meta.labels.min_val: 0,\\n meta.labels.max_val: 9}\\n meta['status_p'] = {meta.labels.units: '',\\n meta.labels.name: 'Diff Proton Flux Status',\\n meta.labels.notes: '',\\n meta.labels.desc: status_desc,\\n meta.labels.fill_val: np.nan,\\n meta.labels.min_val: 0,\\n meta.labels.max_val: 9}\\n meta['anis_ind'] = {meta.labels.units: '',\\n meta.labels.name: 'Anisotropy Index',\\n meta.labels.notes: '',\\n meta.labels.desc: 'Range: 0.0 - 2.0',\\n meta.labels.fill_val: -1.0,\\n meta.labels.min_val: 0.0,\\n meta.labels.max_val: 2.0}\\n meta['eflux_38-53'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name: 'Diff e- Flux 38-53 eV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Electron Flux between 35-53 eV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n meta['eflux_175-315'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name: 'Diff e- Flux 175-315 eV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Electron Flux between 175-315 eV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n meta['pflux_47-68'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name: 'Diff Proton Flux 47-68 keV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Proton Flux between 47-68 keV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n meta['pflux_115-195'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name: 'Diff Proton Flux 115-195 keV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Proton Flux between 115-195 keV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n meta['pflux_310-580'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name: 'Diff Proton Flux 310-580 keV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Proton Flux between 310-580 keV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n meta['pflux_795-1193'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name: 'Diff Proton Flux 795-1193 keV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Proton Flux between 795-1193 keV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n meta['pflux_1060-1900'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name:\\n 'Diff Proton Flux 1060-1900 keV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Proton Flux between 1060-1900 keV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n return data, meta\",\n \"def load_data(filename) :\\r\\n data = Data()\\r\\n data.load(filename)\\r\\n return data\",\n \"def load(self):\\n self.data = NSPSpecIO().read(self.path)\",\n \"def _read_raw_file(\\n self, fname, allow_maxshield, preload, do_check_ext=True, verbose=None\\n ):\\n logger.info(\\\"Opening raw data file %s...\\\" % fname)\\n\\n # Read in the whole file if preload is on and .fif.gz (saves time)\\n if not _file_like(fname):\\n if do_check_ext:\\n endings = (\\n \\\"raw.fif\\\",\\n \\\"raw_sss.fif\\\",\\n \\\"raw_tsss.fif\\\",\\n \\\"_meg.fif\\\",\\n \\\"_eeg.fif\\\",\\n \\\"_ieeg.fif\\\",\\n )\\n endings += tuple([f\\\"{e}.gz\\\" for e in endings])\\n check_fname(fname, \\\"raw\\\", endings)\\n # filename\\n fname = str(_check_fname(fname, \\\"read\\\", True, \\\"fname\\\"))\\n ext = os.path.splitext(fname)[1].lower()\\n whole_file = preload if \\\".gz\\\" in ext else False\\n del ext\\n else:\\n # file-like\\n if not preload:\\n raise ValueError(\\\"preload must be used with file-like objects\\\")\\n whole_file = True\\n fname_rep = _get_fname_rep(fname)\\n ff, tree, _ = fiff_open(fname, preload=whole_file)\\n with ff as fid:\\n # Read the measurement info\\n\\n info, meas = read_meas_info(fid, tree, clean_bads=True)\\n annotations = _read_annotations_fif(fid, tree)\\n\\n # Locate the data of interest\\n raw_node = dir_tree_find(meas, FIFF.FIFFB_RAW_DATA)\\n if len(raw_node) == 0:\\n raw_node = dir_tree_find(meas, FIFF.FIFFB_CONTINUOUS_DATA)\\n if len(raw_node) == 0:\\n raw_node = dir_tree_find(meas, FIFF.FIFFB_IAS_RAW_DATA)\\n if len(raw_node) == 0:\\n raise ValueError(\\\"No raw data in %s\\\" % fname_rep)\\n _check_maxshield(allow_maxshield)\\n with info._unlock():\\n info[\\\"maxshield\\\"] = True\\n del meas\\n\\n if len(raw_node) == 1:\\n raw_node = raw_node[0]\\n\\n # Process the directory\\n directory = raw_node[\\\"directory\\\"]\\n nent = raw_node[\\\"nent\\\"]\\n nchan = int(info[\\\"nchan\\\"])\\n first = 0\\n first_samp = 0\\n first_skip = 0\\n\\n # Get first sample tag if it is there\\n if directory[first].kind == FIFF.FIFF_FIRST_SAMPLE:\\n tag = read_tag(fid, directory[first].pos)\\n first_samp = int(tag.data.item())\\n first += 1\\n _check_entry(first, nent)\\n\\n # Omit initial skip\\n if directory[first].kind == FIFF.FIFF_DATA_SKIP:\\n # This first skip can be applied only after we know the bufsize\\n tag = read_tag(fid, directory[first].pos)\\n first_skip = int(tag.data.item())\\n first += 1\\n _check_entry(first, nent)\\n\\n raw = _RawShell()\\n raw.filename = fname\\n raw.first_samp = first_samp\\n if info[\\\"meas_date\\\"] is None and annotations is not None:\\n # we need to adjust annotations.onset as when there is no meas\\n # date set_annotations considers that the origin of time is the\\n # first available sample (ignores first_samp)\\n annotations.onset -= first_samp / info[\\\"sfreq\\\"]\\n raw.set_annotations(annotations)\\n\\n # Go through the remaining tags in the directory\\n raw_extras = list()\\n nskip = 0\\n orig_format = None\\n\\n for k in range(first, nent):\\n ent = directory[k]\\n # There can be skips in the data (e.g., if the user unclicked)\\n # an re-clicked the button\\n if ent.kind == FIFF.FIFF_DATA_SKIP:\\n tag = read_tag(fid, ent.pos)\\n nskip = int(tag.data.item())\\n elif ent.kind == FIFF.FIFF_DATA_BUFFER:\\n # Figure out the number of samples in this buffer\\n if ent.type == FIFF.FIFFT_DAU_PACK16:\\n nsamp = ent.size // (2 * nchan)\\n elif ent.type == FIFF.FIFFT_SHORT:\\n nsamp = ent.size // (2 * nchan)\\n elif ent.type == FIFF.FIFFT_FLOAT:\\n nsamp = ent.size // (4 * nchan)\\n elif ent.type == FIFF.FIFFT_DOUBLE:\\n nsamp = ent.size // (8 * nchan)\\n elif ent.type == FIFF.FIFFT_INT:\\n nsamp = ent.size // (4 * nchan)\\n elif ent.type == FIFF.FIFFT_COMPLEX_FLOAT:\\n nsamp = ent.size // (8 * nchan)\\n elif ent.type == FIFF.FIFFT_COMPLEX_DOUBLE:\\n nsamp = ent.size // (16 * nchan)\\n else:\\n raise ValueError(\\n \\\"Cannot handle data buffers of type \\\" \\\"%d\\\" % ent.type\\n )\\n if orig_format is None:\\n if ent.type == FIFF.FIFFT_DAU_PACK16:\\n orig_format = \\\"short\\\"\\n elif ent.type == FIFF.FIFFT_SHORT:\\n orig_format = \\\"short\\\"\\n elif ent.type == FIFF.FIFFT_FLOAT:\\n orig_format = \\\"single\\\"\\n elif ent.type == FIFF.FIFFT_DOUBLE:\\n orig_format = \\\"double\\\"\\n elif ent.type == FIFF.FIFFT_INT:\\n orig_format = \\\"int\\\"\\n elif ent.type == FIFF.FIFFT_COMPLEX_FLOAT:\\n orig_format = \\\"single\\\"\\n elif ent.type == FIFF.FIFFT_COMPLEX_DOUBLE:\\n orig_format = \\\"double\\\"\\n\\n # Do we have an initial skip pending?\\n if first_skip > 0:\\n first_samp += nsamp * first_skip\\n raw.first_samp = first_samp\\n first_skip = 0\\n\\n # Do we have a skip pending?\\n if nskip > 0:\\n raw_extras.append(\\n dict(\\n ent=None,\\n first=first_samp,\\n nsamp=nskip * nsamp,\\n last=first_samp + nskip * nsamp - 1,\\n )\\n )\\n first_samp += nskip * nsamp\\n nskip = 0\\n\\n # Add a data buffer\\n raw_extras.append(\\n dict(\\n ent=ent,\\n first=first_samp,\\n last=first_samp + nsamp - 1,\\n nsamp=nsamp,\\n )\\n )\\n first_samp += nsamp\\n\\n next_fname = _get_next_fname(fid, fname_rep, tree)\\n\\n # reformat raw_extras to be a dict of list/ndarray rather than\\n # list of dict (faster access)\\n raw_extras = {key: [r[key] for r in raw_extras] for key in raw_extras[0]}\\n for key in raw_extras:\\n if key != \\\"ent\\\": # dict or None\\n raw_extras[key] = np.array(raw_extras[key], int)\\n if not np.array_equal(raw_extras[\\\"last\\\"][:-1], raw_extras[\\\"first\\\"][1:] - 1):\\n raise RuntimeError(\\\"FIF file appears to be broken\\\")\\n bounds = np.cumsum(\\n np.concatenate([raw_extras[\\\"first\\\"][:1], raw_extras[\\\"nsamp\\\"]])\\n )\\n raw_extras[\\\"bounds\\\"] = bounds\\n assert len(raw_extras[\\\"bounds\\\"]) == len(raw_extras[\\\"ent\\\"]) + 1\\n # store the original buffer size\\n buffer_size_sec = np.median(raw_extras[\\\"nsamp\\\"]) / info[\\\"sfreq\\\"]\\n del raw_extras[\\\"first\\\"]\\n del raw_extras[\\\"last\\\"]\\n del raw_extras[\\\"nsamp\\\"]\\n\\n raw.last_samp = first_samp - 1\\n raw.orig_format = orig_format\\n\\n # Add the calibration factors\\n cals = np.zeros(info[\\\"nchan\\\"])\\n for k in range(info[\\\"nchan\\\"]):\\n cals[k] = info[\\\"chs\\\"][k][\\\"range\\\"] * info[\\\"chs\\\"][k][\\\"cal\\\"]\\n\\n raw._cals = cals\\n raw._raw_extras = raw_extras\\n logger.info(\\n \\\" Range : %d ... %d = %9.3f ... %9.3f secs\\\"\\n % (\\n raw.first_samp,\\n raw.last_samp,\\n float(raw.first_samp) / info[\\\"sfreq\\\"],\\n float(raw.last_samp) / info[\\\"sfreq\\\"],\\n )\\n )\\n\\n raw.info = info\\n\\n logger.info(\\\"Ready.\\\")\\n\\n return raw, next_fname, buffer_size_sec\",\n \"def test_readfile(self):\\n fname = os.path.join(self.datadir, 'monol_testA_E3-50_rebin4_gti') + \\\\\\n HEN_FILE_EXTENSION\\n command = \\\"{0}\\\".format(fname)\\n\\n hen.io.main(command.split())\",\n \"def load(self,factory={}):\\n canSave = self.canSave\\n #--Header\\n inPath = os.path.join(self.fileInfo.dir,self.fileInfo.name)\\n ins = Tes3Reader(self.fileInfo.name,file(inPath,'rb'))\\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\\n self.tes3 = Tes3(name,size,delFlag,recFlag,ins,True)\\n #--Raw data read\\n dial = None\\n while not ins.atEnd():\\n #--Get record info and handle it\\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\\n #--SCPT?\\n if name == 'SCPT':\\n record = Scpt(name,size,delFlag,recFlag,ins,True)\\n self.scripts.append(record)\\n if canSave: self.records.append(record)\\n #--Non-dials?\\n elif canSave:\\n record = Record(name,size,delFlag,recFlag,ins)\\n self.records.append(record)\\n else:\\n ins.seek(size,1,'Record')\\n #--Done Reading\\n ins.close()\",\n \"def load_main_function(self, options, data=None):\\n\\n if self.rdmc.app.redfishinst.is_redfish:\\n eth_type = \\\"ethernetinterface.\\\"\\n else:\\n eth_type = \\\"ethernetnetworkinterface.\\\"\\n\\n linking_dict = {\\n \\\"manager_interfaces\\\": eth_type,\\n \\\"systems_interfaces\\\": eth_type,\\n \\\"manager_network_services\\\": \\\"networkprotocol.\\\",\\n \\\"ilo_date_time\\\": \\\"datetime.\\\",\\n }\\n\\n if not data:\\n data = {}\\n try:\\n if options.encryption:\\n with open(self.eth_file, \\\"rb\\\") as file_handle:\\n data = json.loads(\\n Encryption().decrypt_file(\\n file_handle.read(), options.encryption\\n )\\n )\\n else:\\n with open(self.eth_file, \\\"rb\\\") as file_handle:\\n data = json.loads(file_handle.read())\\n except:\\n raise InvalidFileInputError(\\n \\\"Invalid file formatting found. Verify the file has a \\\"\\n \\\"valid JSON format.\\\"\\n )\\n\\n for ilotype, subsect in data.items():\\n _type = ilotype.split(\\\".\\\")[0]\\n for _path in subsect:\\n if not subsect[_path]:\\n continue\\n elif (\\n \\\"ethernetinterface\\\" in _type.lower()\\n or \\\"ethernetnetworkinterface\\\" in _type.lower()\\n ):\\n if \\\"managers\\\" in _path.lower():\\n self.load_ethernet_aux(_type, _path, data[ilotype][_path])\\n elif \\\"systems\\\" in _path.lower():\\n self.rdmc.ui.warn(\\n \\\"Systems Ethernet Interfaces '%s' \\\"\\n \\\"cannot be modified.\\\" % _path\\n )\\n continue\\n elif \\\"datetime\\\" in _type.lower():\\n if \\\"StaticNTPServers\\\" in list(subsect.get(_path).keys()):\\n # must set NTP Servers to static in OEM then reset iLO for StaticNTPServers\\n # property to appear in iLODateTime\\n if self.rdmc.app.redfishinst.is_redfish:\\n eth_config_type = \\\"ethernetinterface\\\"\\n else:\\n eth_config_type = \\\"ethernetnetworkinterface\\\"\\n for key in list(data.keys()):\\n if key.split(\\\".\\\")[0].lower() == eth_config_type:\\n eth_config_type = key\\n for _path in data[eth_config_type]:\\n if \\\"managers\\\" in _path.lower():\\n try:\\n data[eth_config_type][_path][\\\"DHCPv4\\\"][\\n \\\"UseNTPServers\\\"\\n ] = True\\n data[eth_config_type][_path][\\\"DHCPv6\\\"][\\n \\\"UseNTPServers\\\"\\n ] = True\\n data[eth_config_type][_path][\\\"Oem\\\"][\\n self.rdmc.app.typepath.defs.oemhp\\n ][\\\"DHCPv4\\\"][\\\"UseNTPServers\\\"] = True\\n data[eth_config_type][_path][\\\"Oem\\\"][\\n self.rdmc.app.typepath.defs.oemhp\\n ][\\\"DHCPv6\\\"][\\\"UseNTPServers\\\"] = True\\n self.load_ethernet_aux(\\n eth_config_type,\\n _path,\\n data[eth_config_type][_path],\\n )\\n except KeyError:\\n self.rdmc.ui.printer(\\n \\\"Unable to configure \\\"\\n \\\"'UseNTPServers' for '%s'.\\\\n\\\" % _path\\n )\\n self.rdmc.ui.printer(\\n \\\"iLO must be reset in order for \\\"\\n \\\"changes to static network time protocol servers to \\\"\\n \\\"take effect.\\\\n\\\"\\n )\",\n \"def test_load(api):\\n # upload file to file.io servers\\n uploaded_file = api.upload(\\n tag='test_file',\\n expiry='1d',\\n path='tests/test_file.txt'\\n )\\n\\n # check that instance of FileIO has these fields\\n assert uploaded_file.link\\n assert uploaded_file.key\\n assert uploaded_file.tag\\n assert uploaded_file.path\\n\\n # check that the uploaded file was added to uploaded files list\\n assert api.show_uploads()\\n\\n # check that our list is not empty\\n assert api.file_obj_list\\n\\n # export the file in json format\\n api.export('tests/exported.json')\\n\\n # check that exported file exists\\n assert path.isfile('tests/exported.json')\\n\\n # set it to empty list\\n api.file_obj_list = []\\n\\n # load the file in json format\\n api.load('tests/exported.json')\\n\\n # remove the file\\n remove('tests/exported.json')\\n\\n # check that the uploaded file was added to uploaded files list\\n assert api.show_uploads()\\n\\n # check that our list is not empty\\n assert api.file_obj_list\\n\\n # export the file in pkl format\\n api.export('tests/exported.pkl')\\n\\n # set it to empty list\\n api.file_obj_list = []\\n\\n # load the file in pkl format\\n api.load('tests/exported.pkl')\\n\\n # remove exported.pkl file\\n remove('tests/exported.pkl')\\n\\n # check that the uploaded file was added to uploaded files list\\n assert api.show_uploads()\\n\\n # check that our list is not empty\\n assert api.file_obj_list\",\n \"def load_data(self):\\n \\n # only loader implemented so far !\\n try:\\n _ascii_array = Utilities.load_ascii(filename=self.filename, sep='')\\n start_row = TOF._first_line_number_with_real_data(_ascii_array[0, 0])\\n\\n _tof_column = _ascii_array[start_row:, 0]\\n\\n if not TOF._is_this_numeric(_tof_column[0]):\\n start_row += 1\\n\\n _tof_column = _ascii_array[start_row:, 0]\\n _counts_column = _ascii_array[start_row:, 1]\\n\\n self.tof_array = _tof_column\\n self.counts_array = _counts_column\\n return\\n\\n except IndexError:\\n pass # try another format\\n\\n try:\\n _ascii_array = Utilities.load_ascii(filename=self.filename, sep=',')\\n start_row = TOF._first_line_number_with_real_data(_ascii_array[0, 0])\\n\\n _tof_column = _ascii_array[start_row:, 0] # first row must be excluded in this format\\n\\n if not TOF._is_this_numeric(_tof_column[0]):\\n start_row += 1\\n\\n _tof_column = _ascii_array[start_row:, 0]\\n _counts_column = _ascii_array[start_row:, 1]\\n\\n self.tof_array = _tof_column\\n self.counts_array = _counts_column\\n return\\n\\n except IndexError:\\n raise IndexError(\\\"Format not implemented!\\\")\",\n \"def load(self, fname, snver=1):\\n self._data = self._io.load(fname, snver=snver)\",\n \"def __init__(self):\\n f = open(configuration.dataDirectory+'Muon_ID_iso_Efficiencies_Run_2012ABCD_53X.pkl', 'r')\\n if f :\\n self._map = pickle.load(f)\\n self._range = ''\\n else :\\n print 'ERROR: Input file for muon SF not existing!'\",\n \"def import_equipment_from_file(self, filename='') -> None:\\n if not filename:\\n filename = cif_file_open_dialog(filter=\\\"CIF file (*.cif *.cif_od *.cfx)\\\")\\n if not filename:\\n print('No file given')\\n return\\n doc = read_document_from_cif_file(filename)\\n if not doc:\\n return\\n for block in doc:\\n self._import_block(block, filename)\\n self.show_equipment()\",\n \"def import_file(self, *args, **kwargs):\\n filename = self.file\\n self.completed_layers = []\\n err = GdalErrorHandler()\\n gdal.PushErrorHandler(err.handler)\\n gdal.UseExceptions()\\n configuration_options = kwargs.get('configuration_options', [{'index': 0}])\\n\\n # Configuration options should be a list at this point since the importer can process multiple layers in a\\n # single import\\n if isinstance(configuration_options, dict):\\n configuration_options = [configuration_options]\\n\\n data, inspector = self.open_source_datastore(filename, *args, **kwargs)\\n\\n datastore_layers = inspector.describe_fields()\\n\\n if len(datastore_layers) == 0:\\n logger.debug('No Dataset found')\\n\\n layers_info = []\\n\\n # Add index for any layers configured by name\\n for layer_configuration in configuration_options:\\n if 'layer_name' in layer_configuration:\\n lookup = 'layer_name'\\n elif 'index' in layer_configuration:\\n lookup = 'index'\\n else:\\n lookup = None\\n logger.debug('could not find lookup')\\n continue\\n\\n for datastore_layer in datastore_layers:\\n if datastore_layer.get(lookup) == layer_configuration.get(lookup):\\n layer_configuration.update(datastore_layer)\\n layers_info.append(layer_configuration)\\n\\n for layer_options in layers_info:\\n if layer_options['raster']:\\n \\\"\\\"\\\"\\n File is a raster, we need to convert into optimized GeoTiff\\n and skip any further testing or loading into target_store\\n \\\"\\\"\\\"\\n # Increment filename to make sure target doesn't exists\\n filedir, filebase = os.path.split(filename)\\n outfile = '%s.tif' % os.path.splitext(filebase)[0]\\n fileout = increment_filename(os.path.join(RASTER_FILES, outfile))\\n raster_import(layer_options['path'], fileout)\\n self.completed_layers.append([fileout, layer_options])\\n else:\\n target_file, _ = self.open_target_datastore(self.target_store)\\n target_create_options = []\\n\\n # Prevent numeric field overflow for shapefiles https://trac.osgeo.org/gdal/ticket/5241\\n if target_file.GetDriver().GetName() == 'PostgreSQL':\\n target_create_options.append('PRECISION=NO')\\n\\n layer_options['modified_fields'] = {}\\n layer = data.GetLayer(layer_options.get('index'))\\n layer_name = layer_options.get('name', layer.GetName().lower())\\n layer_type = self.get_layer_type(layer, data)\\n srs = layer.GetSpatialRef()\\n\\n if layer_name.lower() == 'ogrgeojson':\\n try:\\n layer_name = os.path.splitext(os.path.basename(filename))[0].lower()\\n except IndexError:\\n pass\\n\\n layer_name = launder(str(layer_name))\\n\\n # default the layer to 4326 if a spatial reference is not provided\\n if not srs:\\n srs = osr.SpatialReference()\\n srs.ImportFromEPSG(4326)\\n\\n # pass the srs authority code to handlers\\n if srs.AutoIdentifyEPSG() == 0:\\n layer_options['srs'] = '{0}:{1}'.format(srs.GetAuthorityName(None), srs.GetAuthorityCode(None))\\n\\n n = 0\\n while True:\\n n += 1\\n try:\\n target_layer = self.create_target_dataset(target_file, layer_name, srs, layer_type,\\n options=target_create_options)\\n except RuntimeError as e:\\n # logger.exception('exception in creating target dataset')\\n # the layer already exists in the target store, increment the name\\n if 'Use the layer creation option OVERWRITE=YES to replace it.' in e.message:\\n layer_name = increment(layer_name)\\n\\n # try 100 times to increment then break\\n if n >= 100:\\n break\\n\\n continue\\n else:\\n raise e\\n break\\n\\n # adding fields to new layer\\n layer_definition = ogr.Feature(layer.GetLayerDefn())\\n source_fid = None\\n\\n wkb_field = 0\\n\\n for i in range(layer_definition.GetFieldCount()):\\n\\n field_def = layer_definition.GetFieldDefnRef(i)\\n\\n if field_def.GetName() == target_layer.GetFIDColumn() and field_def.GetType() != 0:\\n field_def.SetType(0)\\n\\n if field_def.GetName() != 'wkb_geometry':\\n target_layer.CreateField(field_def)\\n new_name = target_layer.GetLayerDefn().GetFieldDefn(i - wkb_field).GetName()\\n old_name = field_def.GetName()\\n\\n if new_name != old_name:\\n layer_options['modified_fields'][old_name] = new_name\\n\\n if old_name == target_layer.GetFIDColumn() and not layer.GetFIDColumn():\\n source_fid = i\\n else:\\n wkb_field = 1\\n\\n if wkb_field is not 0:\\n layer.SetIgnoredFields(['wkb_geometry'])\\n\\n for i in range(0, layer.GetFeatureCount()):\\n feature = layer.GetFeature(i)\\n\\n if feature and feature.geometry():\\n\\n if not layer.GetFIDColumn():\\n feature.SetFID(-1)\\n\\n if feature.geometry().GetGeometryType() != target_layer.GetGeomType() and \\\\\\n target_layer.GetGeomType() in range(4, 7):\\n\\n conversion_function = ogr.ForceToMultiPolygon\\n\\n if target_layer.GetGeomType() == 5:\\n conversion_function = ogr.ForceToMultiLineString\\n\\n elif target_layer.GetGeomType() == 4:\\n conversion_function = ogr.ForceToMultiPoint\\n\\n geom = ogr.CreateGeometryFromWkb(feature.geometry().ExportToWkb())\\n feature.SetGeometry(conversion_function(geom))\\n\\n if source_fid is not None:\\n feature.SetFID(feature.GetField(source_fid))\\n\\n try:\\n target_layer.CreateFeature(feature)\\n\\n except:\\n for field in range(0, feature.GetFieldCount()):\\n if feature.GetFieldType(field) == ogr.OFTString:\\n try:\\n feature.GetField(field).decode('utf8')\\n except UnicodeDecodeError:\\n feature.SetField(field, decode(feature.GetField(field)))\\n except AttributeError:\\n continue\\n try:\\n target_layer.CreateFeature(feature)\\n except err as e:\\n logger.error('Create feature failed: {0}'.format(gdal.GetLastErrorMsg()))\\n raise e\\n\\n self.completed_layers.append([target_layer.GetName(), layer_options])\\n\\n return self.completed_layers\",\n \"def load(self,factory={}):\\n canSave = self.canSave\\n InfoClass = factory.get('INFO',InfoS) #--Info class from factory.\\n #--Header\\n inPath = os.path.join(self.fileInfo.dir,self.fileInfo.name)\\n ins = Tes3Reader(self.fileInfo.name,file(inPath,'rb'))\\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\\n self.tes3 = Tes3(name,size,delFlag,recFlag,ins,True)\\n #--Raw data read\\n dial = None\\n while not ins.atEnd():\\n #--Get record info and handle it\\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\\n #--DIAL?\\n if name == 'DIAL':\\n dial = Dial(name,size,delFlag,recFlag,ins,True)\\n self.dials.append(dial)\\n if canSave: self.records.append(dial)\\n #--INFO?\\n elif name == 'INFO':\\n info = InfoClass(name,size,delFlag,recFlag,ins,True)\\n self.records.append(info)\\n dial.infos.append(info)\\n self.infos[(dial.type,dial.id,info.id)] = info\\n #--Non-dials?\\n elif canSave:\\n record = Record(name,size,delFlag,recFlag,ins)\\n self.records.append(record)\\n else:\\n ins.seek(size,1,'Record')\\n #--Done Reading\\n ins.close()\",\n \"def loadFromFile():\\n try:\\n f1 = open( \\\"friendshipMap.p\\\", \\\"rb\\\" )\\n friendship_map = pickle.load(f1)\\n f1.close()\\n f2 = open( \\\"businessReviews.p\\\", \\\"rb\\\" )\\n business_reviews = pickle.load(f2)\\n f2.close()\\n f3 = open( \\\"degreeCentrality.p\\\", \\\"rb\\\" )\\n degree_centrality_map = pickle.load(f3)\\n f3.close()\\n f4 = open( \\\"closenessCentrality.p\\\", \\\"rb\\\" )\\n closeness_centrality_map = pickle.load(f4)\\n f4.close()\\n f5 = open( \\\"betweennessCentrality.p\\\", \\\"rb\\\" )\\n betweenness_centrality_map = pickle.load(f5)\\n f5.close()\\n except IOError as e:\\n sys.stderr.write(\\\"I/O error({0}): {1}\\\".format(e.errno, e.strerror)+'\\\\n')\\n sys.stderr.write('Try running with -buildClean = clean!\\\\n')\\n\\n return (friendship_map, business_reviews, degree_centrality_map, closeness_centrality_map, betweenness_centrality_map, YGraph)\",\n \"def load_data_part(fname):\\n if \\\"_data\\\" not in fname:\\n return None\\n # Read data\\n data = pd.read_csv(fname)\\n # events file\\n events_fname = fname.replace('_data', '_events')\\n # read event file\\n labels = pd.read_csv(events_fname)\\n clean = data.drop(['id'], axis=1) # remove id\\n labels = labels.drop(['id'], axis=1) # remove id\\n return clean, labels\",\n \"def load_pfile(self, **kwargs):\\r\\n pfile = kwargs['pfile']\\r\\n filetype = kwargs['filetype']\\r\\n\\r\\n # Loads the pfile and finds the indices, still need to sync and parse.\\r\\n self.pfile = PFILE(pfile, filetype=filetype)\\r\\n # self.pfile.sync(tstep='auto')\\r\",\n \"def __load_model(self):\\n loaded = load(self.__file_name)\\n self.__model = loaded['model']\\n self.__meta_data = loaded['metadata']\\n self.__is_ready = True\",\n \"def load(self, input):\\n return\",\n \"def load(self):\\n raise NotImplementedError()\",\n \"def load(self):\\n raise NotImplementedError()\",\n \"def load(self):\\n canSave = self.canSave\\n #--Header\\n inPath = os.path.join(self.fileInfo.dir,self.fileInfo.name)\\n ins = Tes3Reader(self.fileInfo.name,file(inPath,'rb'))\\n (name,size,delFlag,recFlag) = ins.unpack('4s3i',16,'REC_HEAD')\\n self.tes3 = Tes3(name,size,delFlag,recFlag,ins,True)\\n #--Raw data read\\n while not ins.atEnd():\\n #--Get record info and handle it\\n (name,size,delFlag,recFlag) = ins.unpackRecHeader()\\n #--LEVC?\\n if name == 'LEVC':\\n levc = Levc(name,size,delFlag,recFlag,ins,True)\\n self.levcs[levc.id] = levc\\n if canSave: self.records.append(levc)\\n #print ' Added:',levc.id\\n elif name == 'LEVI':\\n levi = Levi(name,size,delFlag,recFlag,ins,True)\\n self.levis[levi.id] = levi\\n if canSave: self.records.append(levi)\\n #print ' Added:',levi.id\\n #--Other\\n elif canSave:\\n record = Record(name,size,delFlag,recFlag,ins)\\n self.records.append(record)\\n else:\\n ins.seek(size,1,'Record')\\n #--Done Reading\\n ins.close()\",\n \"def load(path):\\n pass\",\n \"def doImport(self,textFile):\\n self.loadText(textFile)\\n self.getBooks()\\n #self.copyBooks()\\n self.genLibData()\\n self.genLibCells()\\n self.sortRecords()\",\n \"def load_synthetic_data():\\n\\n pickle_object = FM().data_file \\n\\n with pickle_object.open('rb') as data_file: \\n return pickle.load(data_file)\",\n \"def _load(self):\\n service_manager = helper_util.getServiceManager(self.hostname, self.port,\\n self.uno_path,\\n self.office_binary_path)\\n desktop = service_manager.createInstance(\\\"com.sun.star.frame.Desktop\\\")\\n uno_url = self.systemPathToFileUrl(self.document_url)\\n uno_document = desktop.loadComponentFromURL(uno_url, \\\"_blank\\\", 0, ())\\n if not uno_document:\\n raise AttributeError(\\\"This document can not be loaded or is empty\\\")\\n if self.refresh:\\n # Before converting to expected format, refresh dynamic\\n # value inside document.\\n dispatcher = service_manager.createInstance(\\\"com.sun.star.frame.DispatchHelper\\\")\\n for uno_command in ('UpdateFields', 'UpdateAll', 'UpdateInputFields',\\n 'UpdateAllLinks', 'UpdateCharts',):\\n dispatcher.executeDispatch(uno_document.getCurrentController().getFrame(),\\n '.uno:%s' % uno_command, '', 0, ())\\n module_manager = service_manager.createInstance(\\\"com.sun.star.frame.ModuleManager\\\")\\n self.document_type = module_manager.identify(uno_document)\\n self.document_loaded = uno_document\",\n \"def F(f):\\n return datafile(f, __name__)\",\n \"def load(self):\\n settings_path = os.path.join(self.file_path, \\\"__file_data.json\\\")\\n if os.path.exists( settings_path ):\\n self.fileList = simplejson.loads( open( settings_path, 'r' ).read() )\\n\\n settings_path = os.path.join(self.file_path, \\\"__user_data.json\\\")\\n if os.path.exists( settings_path ):\\n self.userList = simplejson.loads( open( settings_path, 'r' ).read() )\",\n \"def do_load(self, line):\\n cmd_args = io.parse_cmd_args(line, io.load_cmd_pattern)\\n if cmd_args:\\n success = self.manager.load(**cmd_args)\\n if success:\\n self.console_print(\\\"Yippee! load successful!\\\", settings.INFO_FORMAT)\\n else:\\n self.console_print(\\\"Sorry, the data could not be loaded from file.\\\", settings.ERROR_FORMAT)\\n else:\\n self.console_print(settings.COMMMAND_ARGS_ERROR_MSG, settings.ERROR_FORMAT)\",\n \"def read_input():\\n\\n filenames = sorted(glob.glob(\\\"%s/openflow_input/*\\\" % root_dir))\\n\\n for filename in filenames:\\n log(\\\"Processing struct file: \\\" + filename)\\n ofinput = process_input_file(filename)\\n\\n # Populate global state\\n for wire_version in ofinput.wire_versions:\\n version_name = of_g.of_version_wire2name[wire_version]\\n versions[version_name]['classes'].update(copy.deepcopy(ofinput.classes))\\n of_g.ordered_classes[wire_version].extend(ofinput.ordered_classes)\",\n \"def load(self, *args, **kwargs):\\n pass\",\n \"def _load(self, file_path, **kwargs):\\n raise NotImplementedError()\",\n \"def LoadBatch(filename):\",\n \"def load (self, filename) :\\n\\t\\tserialFile = open (filename, \\\"rb\\\")\\n\\t\\tself.production_rules = pickle.load (serialFile)\\n\\t\\tself.unitrelation = pickle.load (serialFile)\\n\\t\\tself.labels = pickle.load (serialFile)\\n\\t\\tself.keeper = pickle.load (serialFile)\\n\\t\\tself.strnodes = pickle.load(serialFile)\\n\\t\\tself.tokens = pickle.load (serialFile)\\n\\t\\tserialFile.close()\",\n \"def __init__(self, filename=None,\\n astrotarget=None,data_index=0,\\n dataslice0=None,dataslice1=None,\\n empty=False, **kwargs):\\n self.__build__(data_index=data_index)\\n\\n if empty:\\n return\\n \\n if filename is not None:\\n force_it = kwargs.pop(\\\"force_it\\\",True)\\n self.load(filename,force_it=force_it,\\n dataslice0=dataslice0,\\n dataslice1=dataslice1,\\n **kwargs)\\n # - Set the target if any\\n if astrotarget is not None:\\n self.set_target(astrotarget)\",\n \"def load_data(self):\\n if self.debug:\\n print(\\\"Loading data\\\")\",\n \"def load_data(self, **kwargs):\\n type = kwargs['type']\\n file = kwargs['file']\\n with open(file, 'r') as data_file:\\n for line in data_file:\\n line = line[:-1]\\n items_dict = ast.literal_eval(line)\\n\\n item = type.from_dict(items_dict)\\n\\n self.add_item(item, lambda i: i.uid)\",\n \"def _import(self, datadict):\\n self.GUID = datadict.get(\\\"GUID\\\", uuid.uuid1())\\n self.FileName = datadict.get(\\\"FileName\\\", \\\"\\\")\\n self.Name = datadict.get(\\\"Name\\\", \\\"\\\")\\n self.Projects = datadict.get(\\\"Projects\\\", [])\\n self.VSVersion = datadict.get(\\\"VSVersion\\\", None)\",\n \"def load_object(fpath):\\r\\n with open(fpath, 'rb') as i:\\r\\n return pickle.load(i)\",\n \"def load_aif(\\n obj: aif.Graph,\\n name: t.Optional[str] = None,\\n config: Config = DefaultConfig,\\n) -> Graph:\\n g = config.GraphClass(name)\\n\\n for aif_node in obj[\\\"nodes\\\"]:\\n node = (\\n atom_from_aif(aif_node, config)\\n if aif_node[\\\"type\\\"] == \\\"I\\\"\\n else scheme_from_aif(aif_node, config)\\n )\\n\\n if node:\\n g.add_node(node)\\n\\n for aif_edge in obj[\\\"edges\\\"]:\\n if edge := edge_from_aif(aif_edge, g.nodes, config):\\n g.add_edge(edge)\\n\\n return g\",\n \"def __init__(self):\\n f = open(configuration.dataDirectory+'MuonEfficiencies_Run_2012A_2012_B_53X.pkl', 'r')\\n if f :\\n self._map = pickle.load(f)\\n self._eta_range = ''\\n self._pt_range = ''\\n else :\\n print 'ERROR: Input file for Trigger efficiencies not existing!'\",\n \"def __init__(self):\\n f = open(configuration.dataDirectory+'MuonEfficiencies_Run_2012A_2012_B_53X.pkl', 'r')\\n if f :\\n self._map = pickle.load(f)\\n self._eta_range = ''\\n self._pt_range = ''\\n else :\\n print 'ERROR: Input file for Trigger efficiencies not existing!'\",\n \"def load(logFile):\\n pass #TODO\",\n \"def _read_file(self):\\n\\n with open(self.file_name, 'rb') as f:\\n new_test = struct.unpack('<l', f.read(8)[4:])[0]\\n f.close()\\n\\n with open(self.file_name, 'rb') as f:\\n old_test = struct.unpack('<h', f.read(6)[4:])[0]\\n f.close()\\n\\n with open(self.file_name, 'rb') as f:\\n other_test = struct.unpack('<l', f.read(20)[16:])[0]\\n f.close()\\n\\n open_file = open(self.file_name, 'rb')\\n\\n if (other_test==202):\\n raw = open_file.read(1236)[11:]\\n self.model = '202'\\n elif ((not new_test==102) and old_test==102):\\n raw = open_file.read(1133)\\n self.model = '102old'\\n elif (new_test==102 and old_test==102):\\n raw = open_file.read(1224)\\n self.model = '102new'\\n\\n self.header = DpHeader(raw, self.model)\\n\\n self.data = DpData(open_file, \\n self.model, \\n self.header.interferogram_size, \\n self.header.number_of_coadds, \\n 2048*self.header.zero_fill,\\n self.header.laser_wavelength_microns, \\n self.header.dispersion_constant_xm,\\n self.header.dispersion_constant_xb)\\n\\n open_file.close()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6358744","0.62189686","0.6196685","0.6185245","0.6043738","0.5999552","0.59746337","0.5964088","0.5944215","0.5927775","0.5897965","0.58831894","0.5869329","0.5848849","0.58181727","0.5810083","0.5804512","0.577736","0.576331","0.57621175","0.5762104","0.57602143","0.5758326","0.57557267","0.57436126","0.5741986","0.57318664","0.57318664","0.57318664","0.57318664","0.57044774","0.5691296","0.56688166","0.56122416","0.56080985","0.55898607","0.55884653","0.5579047","0.55579287","0.5551302","0.5551302","0.55457485","0.5540401","0.5537634","0.55355173","0.5524949","0.5512765","0.5511954","0.55038965","0.5497772","0.5492163","0.5490701","0.54899055","0.54882944","0.54860896","0.5479889","0.5466846","0.5462482","0.54620886","0.5423454","0.5423006","0.5403777","0.5401884","0.5394161","0.5387714","0.5383772","0.53721434","0.53716564","0.5371453","0.5368885","0.5364547","0.53587323","0.53563404","0.5356022","0.5350395","0.5347933","0.5346808","0.5346808","0.53461576","0.5342228","0.5339782","0.5335759","0.5333362","0.53278315","0.53257835","0.53243214","0.5323729","0.5319341","0.5318134","0.53174126","0.5311326","0.53105253","0.5308928","0.530245","0.52990204","0.52923906","0.5292363","0.5285798","0.5285798","0.52853703","0.528348"],"string":"[\n \"0.6358744\",\n \"0.62189686\",\n \"0.6196685\",\n \"0.6185245\",\n \"0.6043738\",\n \"0.5999552\",\n \"0.59746337\",\n \"0.5964088\",\n \"0.5944215\",\n \"0.5927775\",\n \"0.5897965\",\n \"0.58831894\",\n \"0.5869329\",\n \"0.5848849\",\n \"0.58181727\",\n \"0.5810083\",\n \"0.5804512\",\n \"0.577736\",\n \"0.576331\",\n \"0.57621175\",\n \"0.5762104\",\n \"0.57602143\",\n \"0.5758326\",\n \"0.57557267\",\n \"0.57436126\",\n \"0.5741986\",\n \"0.57318664\",\n \"0.57318664\",\n \"0.57318664\",\n \"0.57318664\",\n \"0.57044774\",\n \"0.5691296\",\n \"0.56688166\",\n \"0.56122416\",\n \"0.56080985\",\n \"0.55898607\",\n \"0.55884653\",\n \"0.5579047\",\n \"0.55579287\",\n \"0.5551302\",\n \"0.5551302\",\n \"0.55457485\",\n \"0.5540401\",\n \"0.5537634\",\n \"0.55355173\",\n \"0.5524949\",\n \"0.5512765\",\n \"0.5511954\",\n \"0.55038965\",\n \"0.5497772\",\n \"0.5492163\",\n \"0.5490701\",\n \"0.54899055\",\n \"0.54882944\",\n \"0.54860896\",\n \"0.5479889\",\n \"0.5466846\",\n \"0.5462482\",\n \"0.54620886\",\n \"0.5423454\",\n \"0.5423006\",\n \"0.5403777\",\n \"0.5401884\",\n \"0.5394161\",\n \"0.5387714\",\n \"0.5383772\",\n \"0.53721434\",\n \"0.53716564\",\n \"0.5371453\",\n \"0.5368885\",\n \"0.5364547\",\n \"0.53587323\",\n \"0.53563404\",\n \"0.5356022\",\n \"0.5350395\",\n \"0.5347933\",\n \"0.5346808\",\n \"0.5346808\",\n \"0.53461576\",\n \"0.5342228\",\n \"0.5339782\",\n \"0.5335759\",\n \"0.5333362\",\n \"0.53278315\",\n \"0.53257835\",\n \"0.53243214\",\n \"0.5323729\",\n \"0.5319341\",\n \"0.5318134\",\n \"0.53174126\",\n \"0.5311326\",\n \"0.53105253\",\n \"0.5308928\",\n \"0.530245\",\n \"0.52990204\",\n \"0.52923906\",\n \"0.5292363\",\n \"0.5285798\",\n \"0.5285798\",\n \"0.52853703\",\n \"0.528348\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94997,"cells":{"query":{"kind":"string","value":"Returns the name of the dataset series which this datasource operates on"},"document":{"kind":"string","value":"def getName(self):\n\t\treturn self.name"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def dataset_name(self):\n return self.dataset.name","def get_dataset_name(self):\n raise NotImplementedError","def get_dataset_name(self):\n return self.dataset_name","def dataset_name(self):\n return self._dataset_name","def series_names(self):\r\n return self.names","def short_name(self):\r\n raise NotImplementedError('BaseDataSource::short_name not specified.')","def name(self):\n if ( self._typeSensor == _production):\n name = \"myEnedis.%s.production\" %(self._myDataSensorEnedis.get_PDL_ID())\n else:\n name = \"myEnedis.%s\" %(self._myDataSensorEnedis.get_PDL_ID())\n return name","def __get_dataset_name(self):\n d = gdal.Open(self.fname)\n # Get band metadata\n b = d.GetRasterBand(1)\n md = b.GetMetadata()\n\n if 'data_var' in md:\n return md['data_var']\n else:\n fnames = d.GetFileList()\n if len(fnames) > 2:\n d = gdal.Open(fnames[1])\n # Get band metadata\n b = d.GetRasterBand(1)\n md = b.GetMetadata()\n if 'data_var' in md:\n return md['data_var']\n else:\n return 'data'\n else:\n return 'data'","def assemble_chart(self):\n return self.name","def GetSeriesColumnName(series):\n return '{} & {} & QC {}'.format(series.site_code, series.variable_code, series.quality_control_level_code)","def series_id(self) -> str:\n return self.get_main_information()['ParentSeries']","def name(self):\n return 'data_extraction_for_' + '_'.join(self.names).lower()","def _dataset_name(self):\n return f'Libri{self.task}Mix'","def name(self):\n return f\"{habitica.DOMAIN}_{self._name}_{self._sensor_name}\"","def get_data_name(self, idx):\n name = None\n if type(idx) is int:\n n = self.data_count()\n assert 0 <= idx <= n - 1, \"Bad data index\"\n name = self.data[idx].name\n return(name)","def axis_name(self):\n return self._axis_name","def name(self):\n return self._sensor.name","def get_sensor_name(self):\n return self.data[1]","def name(self) -> str:\n return f\"{self._inst} {self._sid_data['sid']} {self._data[self._sid_data['sid_name']]}\"","def get_filename(self):\n return self.ds_filename","def dc_name(self):\n return self.container_name","def get_measurement_objects_name(self):\n return self.object_name.value","def get_archive_name(self) -> str:\n # TODO: Support for user-defined or metadata-based (e.g. title) name\n return \"dataset\"","def getSeriesFK(self):\n return self.getDbRecord().getColumnValue(SERIES_COLUMN)","def name(self):\n return self.__name__","def get_name(self):\n raise NotImplementedError","def get_name(self):\n raise NotImplementedError","def get_name(self):\n raise NotImplementedError","def get_name(self):\n raise NotImplementedError","def get_name(self):\n\n\t\treturn self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name(self):\n return self.__name","def name ( self ) :\n return self.__name if self.__name else ''","def get_name(self):\n\t\treturn self.__name","def getName(self):\n return self.__name__","def getDatasetName(sitemover, datasetDict, lfn, pdsname):\n # (dsname_report is the same as dsname but might contain _subNNN parts)\n\n # get the dataset name from the dictionary\n if datasetDict:\n try:\n dsname = datasetDict[lfn]\n except Exception, e:\n tolog(\"!!WARNING!!2999!! Could not get dsname from datasetDict for file %s: %s, %s (using default %s)\" % (lfn, e, str(datasetDict), pdsname))\n dsname = pdsname\n else:\n dsname = pdsname\n\n # save the original dsname for the tracing report\n dsname_report = dsname\n\n # remove any _subNNN parts from the dataset name (from now on dsname will only be used to create SE destination paths)\n dsname = sitemover.removeSubFromDatasetName(dsname)\n\n tolog(\"File %s will go to dataset %s\" % (lfn, dsname))\n\n return dsname, dsname_report","def series_axis(self):\n return self.container['series_axis']","def get_sensor_name(self):\n\n return self._sensor_results_list[0].get_sensor_model()","def get_name(self):\n return self.__name","def get_name(self):\n return self.__name","def get_name(self):\n return self.__name","def name(self):\n return f\"{self._tc_object.name} {SENSOR_TYPES[self.type][0]}\"","def name(self) -> str:\n return self.observation.name","def get_name(self):\n return self.col_name","def name(self):\n return f\"{self._name} {SENSOR_TYPES[self.sensor][0]}\"","def get_name(self):\n\t\treturn self.source.get_name()","def get_name(self):\r\n return self.__name","def get_name(self):\r\n return self.__name","def get_name(self):\r\n return self.__name","def get_name(self):\r\n return self.__name","def get_name(self):\r\n raise NotImplementedError","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def name(self) -> str:\n return self.__name","def getName(self):\n return _libsbml.SBase_getName(self)","def getName(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n raise NotImplementedError","def name(self):\n return f\"{self._name} {self._sensor_name}\"","def name(self):\n return f\"{self._name}_{self._sensor}\"","def name(self):\n return self.__class__.__name__","def name(self):\n return self.__class__.__name__","def name(self):\n return self.__class__.__name__","def name(self):\n return self.__class__.__name__","def name(self):\n return self.__class__.__name__","def get_name(self) -> str:\n raise NotImplementedError","def name(self):\n return self.measurement_profile.name","def get_name(self):\n return","def getCoaddDatasetName(self):\n warpType = self.config.warpType\n suffix = \"\" if warpType == \"direct\" else warpType[0].upper() + warpType[1:]\n return self.config.coaddName + \"Coadd\" + suffix","def getName(self):\n return self.__name","def name(self):\n\t\treturn self._name","def name(self):\n\t\treturn self._name","def name(self):\n\n return self.__class__.__name__","def dataset_id(self) -> str:\n return self._dataset_id","def get_name(self):\n pass","def get_name(self):\n pass","def getname(self):\n return self.__name","def name(self):\n raise NotImplementedError # pragma: no cover","def get_name(self):\n return self._label","def get_name(self):\n return self._sName","def getName(self):\r\n return self.__name__"],"string":"[\n \"def dataset_name(self):\\n return self.dataset.name\",\n \"def get_dataset_name(self):\\n raise NotImplementedError\",\n \"def get_dataset_name(self):\\n return self.dataset_name\",\n \"def dataset_name(self):\\n return self._dataset_name\",\n \"def series_names(self):\\r\\n return self.names\",\n \"def short_name(self):\\r\\n raise NotImplementedError('BaseDataSource::short_name not specified.')\",\n \"def name(self):\\n if ( self._typeSensor == _production):\\n name = \\\"myEnedis.%s.production\\\" %(self._myDataSensorEnedis.get_PDL_ID())\\n else:\\n name = \\\"myEnedis.%s\\\" %(self._myDataSensorEnedis.get_PDL_ID())\\n return name\",\n \"def __get_dataset_name(self):\\n d = gdal.Open(self.fname)\\n # Get band metadata\\n b = d.GetRasterBand(1)\\n md = b.GetMetadata()\\n\\n if 'data_var' in md:\\n return md['data_var']\\n else:\\n fnames = d.GetFileList()\\n if len(fnames) > 2:\\n d = gdal.Open(fnames[1])\\n # Get band metadata\\n b = d.GetRasterBand(1)\\n md = b.GetMetadata()\\n if 'data_var' in md:\\n return md['data_var']\\n else:\\n return 'data'\\n else:\\n return 'data'\",\n \"def assemble_chart(self):\\n return self.name\",\n \"def GetSeriesColumnName(series):\\n return '{} & {} & QC {}'.format(series.site_code, series.variable_code, series.quality_control_level_code)\",\n \"def series_id(self) -> str:\\n return self.get_main_information()['ParentSeries']\",\n \"def name(self):\\n return 'data_extraction_for_' + '_'.join(self.names).lower()\",\n \"def _dataset_name(self):\\n return f'Libri{self.task}Mix'\",\n \"def name(self):\\n return f\\\"{habitica.DOMAIN}_{self._name}_{self._sensor_name}\\\"\",\n \"def get_data_name(self, idx):\\n name = None\\n if type(idx) is int:\\n n = self.data_count()\\n assert 0 <= idx <= n - 1, \\\"Bad data index\\\"\\n name = self.data[idx].name\\n return(name)\",\n \"def axis_name(self):\\n return self._axis_name\",\n \"def name(self):\\n return self._sensor.name\",\n \"def get_sensor_name(self):\\n return self.data[1]\",\n \"def name(self) -> str:\\n return f\\\"{self._inst} {self._sid_data['sid']} {self._data[self._sid_data['sid_name']]}\\\"\",\n \"def get_filename(self):\\n return self.ds_filename\",\n \"def dc_name(self):\\n return self.container_name\",\n \"def get_measurement_objects_name(self):\\n return self.object_name.value\",\n \"def get_archive_name(self) -> str:\\n # TODO: Support for user-defined or metadata-based (e.g. title) name\\n return \\\"dataset\\\"\",\n \"def getSeriesFK(self):\\n return self.getDbRecord().getColumnValue(SERIES_COLUMN)\",\n \"def name(self):\\n return self.__name__\",\n \"def get_name(self):\\n raise NotImplementedError\",\n \"def get_name(self):\\n raise NotImplementedError\",\n \"def get_name(self):\\n raise NotImplementedError\",\n \"def get_name(self):\\n raise NotImplementedError\",\n \"def get_name(self):\\n\\n\\t\\treturn self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name(self):\\n return self.__name\",\n \"def name ( self ) :\\n return self.__name if self.__name else ''\",\n \"def get_name(self):\\n\\t\\treturn self.__name\",\n \"def getName(self):\\n return self.__name__\",\n \"def getDatasetName(sitemover, datasetDict, lfn, pdsname):\\n # (dsname_report is the same as dsname but might contain _subNNN parts)\\n\\n # get the dataset name from the dictionary\\n if datasetDict:\\n try:\\n dsname = datasetDict[lfn]\\n except Exception, e:\\n tolog(\\\"!!WARNING!!2999!! Could not get dsname from datasetDict for file %s: %s, %s (using default %s)\\\" % (lfn, e, str(datasetDict), pdsname))\\n dsname = pdsname\\n else:\\n dsname = pdsname\\n\\n # save the original dsname for the tracing report\\n dsname_report = dsname\\n\\n # remove any _subNNN parts from the dataset name (from now on dsname will only be used to create SE destination paths)\\n dsname = sitemover.removeSubFromDatasetName(dsname)\\n\\n tolog(\\\"File %s will go to dataset %s\\\" % (lfn, dsname))\\n\\n return dsname, dsname_report\",\n \"def series_axis(self):\\n return self.container['series_axis']\",\n \"def get_sensor_name(self):\\n\\n return self._sensor_results_list[0].get_sensor_model()\",\n \"def get_name(self):\\n return self.__name\",\n \"def get_name(self):\\n return self.__name\",\n \"def get_name(self):\\n return self.__name\",\n \"def name(self):\\n return f\\\"{self._tc_object.name} {SENSOR_TYPES[self.type][0]}\\\"\",\n \"def name(self) -> str:\\n return self.observation.name\",\n \"def get_name(self):\\n return self.col_name\",\n \"def name(self):\\n return f\\\"{self._name} {SENSOR_TYPES[self.sensor][0]}\\\"\",\n \"def get_name(self):\\n\\t\\treturn self.source.get_name()\",\n \"def get_name(self):\\r\\n return self.__name\",\n \"def get_name(self):\\r\\n return self.__name\",\n \"def get_name(self):\\r\\n return self.__name\",\n \"def get_name(self):\\r\\n return self.__name\",\n \"def get_name(self):\\r\\n raise NotImplementedError\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def name(self) -> str:\\n return self.__name\",\n \"def getName(self):\\n return _libsbml.SBase_getName(self)\",\n \"def getName(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n raise NotImplementedError\",\n \"def name(self):\\n return f\\\"{self._name} {self._sensor_name}\\\"\",\n \"def name(self):\\n return f\\\"{self._name}_{self._sensor}\\\"\",\n \"def name(self):\\n return self.__class__.__name__\",\n \"def name(self):\\n return self.__class__.__name__\",\n \"def name(self):\\n return self.__class__.__name__\",\n \"def name(self):\\n return self.__class__.__name__\",\n \"def name(self):\\n return self.__class__.__name__\",\n \"def get_name(self) -> str:\\n raise NotImplementedError\",\n \"def name(self):\\n return self.measurement_profile.name\",\n \"def get_name(self):\\n return\",\n \"def getCoaddDatasetName(self):\\n warpType = self.config.warpType\\n suffix = \\\"\\\" if warpType == \\\"direct\\\" else warpType[0].upper() + warpType[1:]\\n return self.config.coaddName + \\\"Coadd\\\" + suffix\",\n \"def getName(self):\\n return self.__name\",\n \"def name(self):\\n\\t\\treturn self._name\",\n \"def name(self):\\n\\t\\treturn self._name\",\n \"def name(self):\\n\\n return self.__class__.__name__\",\n \"def dataset_id(self) -> str:\\n return self._dataset_id\",\n \"def get_name(self):\\n pass\",\n \"def get_name(self):\\n pass\",\n \"def getname(self):\\n return self.__name\",\n \"def name(self):\\n raise NotImplementedError # pragma: no cover\",\n \"def get_name(self):\\n return self._label\",\n \"def get_name(self):\\n return self._sName\",\n \"def getName(self):\\r\\n return self.__name__\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76386154","0.7613764","0.7546239","0.75300765","0.7156447","0.6760011","0.6729094","0.6698387","0.66739553","0.6590775","0.6491004","0.64055467","0.6366336","0.63660336","0.63432425","0.63402456","0.63139105","0.6290302","0.6242632","0.62166566","0.6213114","0.62119496","0.62027806","0.6202306","0.6178776","0.6159616","0.6159616","0.6159616","0.6159616","0.6154153","0.61507297","0.61507297","0.61507297","0.61507297","0.61507297","0.61507297","0.61507297","0.61507297","0.61507297","0.61507297","0.6142661","0.61153936","0.61031866","0.6099745","0.6094658","0.60743725","0.6074302","0.6074302","0.6074302","0.60698426","0.6069239","0.60685843","0.60685307","0.6062064","0.6056453","0.6056453","0.6056453","0.6056453","0.60386145","0.60333526","0.60333526","0.60333526","0.60333526","0.60333526","0.60333526","0.60333526","0.60332686","0.60317624","0.6028028","0.6028028","0.6028028","0.6028028","0.6028028","0.6028028","0.6028028","0.6028028","0.6028028","0.6028028","0.6027506","0.6021898","0.6004214","0.6004214","0.6004214","0.6004214","0.6004214","0.60029376","0.6001677","0.59987205","0.5992488","0.59914035","0.5986139","0.5986139","0.5986116","0.59745616","0.5974038","0.5974038","0.59738463","0.59700704","0.5969258","0.59650075","0.59642047"],"string":"[\n \"0.76386154\",\n \"0.7613764\",\n \"0.7546239\",\n \"0.75300765\",\n \"0.7156447\",\n \"0.6760011\",\n \"0.6729094\",\n \"0.6698387\",\n \"0.66739553\",\n \"0.6590775\",\n \"0.6491004\",\n \"0.64055467\",\n \"0.6366336\",\n \"0.63660336\",\n \"0.63432425\",\n \"0.63402456\",\n \"0.63139105\",\n \"0.6290302\",\n \"0.6242632\",\n \"0.62166566\",\n \"0.6213114\",\n \"0.62119496\",\n \"0.62027806\",\n \"0.6202306\",\n \"0.6178776\",\n \"0.6159616\",\n \"0.6159616\",\n \"0.6159616\",\n \"0.6159616\",\n \"0.6154153\",\n \"0.61507297\",\n \"0.61507297\",\n \"0.61507297\",\n \"0.61507297\",\n \"0.61507297\",\n \"0.61507297\",\n \"0.61507297\",\n \"0.61507297\",\n \"0.61507297\",\n \"0.61507297\",\n \"0.6142661\",\n \"0.61153936\",\n \"0.61031866\",\n \"0.6099745\",\n \"0.6094658\",\n \"0.60743725\",\n \"0.6074302\",\n \"0.6074302\",\n \"0.6074302\",\n \"0.60698426\",\n \"0.6069239\",\n \"0.60685843\",\n \"0.60685307\",\n \"0.6062064\",\n \"0.6056453\",\n \"0.6056453\",\n \"0.6056453\",\n \"0.6056453\",\n \"0.60386145\",\n \"0.60333526\",\n \"0.60333526\",\n \"0.60333526\",\n \"0.60333526\",\n \"0.60333526\",\n \"0.60333526\",\n \"0.60333526\",\n \"0.60332686\",\n \"0.60317624\",\n \"0.6028028\",\n \"0.6028028\",\n \"0.6028028\",\n \"0.6028028\",\n \"0.6028028\",\n \"0.6028028\",\n \"0.6028028\",\n \"0.6028028\",\n \"0.6028028\",\n \"0.6028028\",\n \"0.6027506\",\n \"0.6021898\",\n \"0.6004214\",\n \"0.6004214\",\n \"0.6004214\",\n \"0.6004214\",\n \"0.6004214\",\n \"0.60029376\",\n \"0.6001677\",\n \"0.59987205\",\n \"0.5992488\",\n \"0.59914035\",\n \"0.5986139\",\n \"0.5986139\",\n \"0.5986116\",\n \"0.59745616\",\n \"0.5974038\",\n \"0.5974038\",\n \"0.59738463\",\n \"0.59700704\",\n \"0.5969258\",\n \"0.59650075\",\n \"0.59642047\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":94998,"cells":{"query":{"kind":"string","value":"Returns the ctf of the dataset series which this datasource operates on"},"document":{"kind":"string","value":"def getColorTransferFunction(self):\n\t\treturn self.ctf"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getCDF(self):\n return self.cdfSample","def CFL(self):\n return self.__CFL","def get_cffts(self):\n return [\n rfft(self.nx, self.dx, fft=self.tfft, ny=self.ny,\n dy=self.dy).get_cfft(),\n rfft(self.nx, self.dx, fft=self.efft, ny=self.ny,\n dy=self.dy).get_cfft(),\n rfft(self.nx, self.dx, fft=self.bfft, ny=self.ny,\n dy=self.dy).get_cfft()\n ]","def cpf(self):\n return self._cpf","def get_cfft(self):\n return self.get_rfft().get_cfft()","def tctfdfc(x):\n if isinstance(x,Fdf) :\n pass\n else : \n x = Fdf.constant(x)\n return x","def get_crds_fc(self, axes=None, shaped=False):\n return self._src_crds.get_crds_fc(axes=axes, shaped=shaped)","def coherency(self):\r\n data = self.input.data\r\n tseries_length = data.shape[0]\r\n spectrum_length = self.spectrum.shape[-1]\r\n\r\n coherency = np.zeros((tseries_length,\r\n tseries_length,\r\n spectrum_length), dtype=complex)\r\n\r\n for i in range(tseries_length):\r\n for j in range(i, tseries_length):\r\n coherency[i][j] = tsa.coherency_spec(self.spectrum[i][j],\r\n self.spectrum[i][i],\r\n self.spectrum[j][j])\r\n\r\n idx = tril_indices(tseries_length, -1)\r\n coherency[idx[0], idx[1], ...] = coherency[idx[1], idx[0], ...].conj()\r\n\r\n return coherency","def cdf(x, point):\n raise NotImplementedError(\"The cdf method has not yet been implemented.\")","def coherence(self):\r\n\r\n #XXX Calculate this from the standard output, instead of recalculating\r\n #the coherence:\r\n\r\n tseries_length = self.input.data.shape[0]\r\n spectrum_length = self.spectrum.shape[-1]\r\n coherence = np.zeros((tseries_length,\r\n tseries_length,\r\n spectrum_length))\r\n\r\n for i in range(tseries_length):\r\n for j in range(i, tseries_length):\r\n coherence[i][j] = tsa.coherence_spec(self.spectrum[i][j],\r\n self.spectrum[i][i],\r\n self.spectrum[j][j])\r\n\r\n idx = tril_indices(tseries_length, -1)\r\n coherence[idx[0], idx[1], ...] = coherence[idx[1], idx[0], ...].conj()\r\n\r\n return coherence","def getCoaddDatasetName(self):\n warpType = self.config.warpType\n suffix = \"\" if warpType == \"direct\" else warpType[0].upper() + warpType[1:]\n return self.config.coaddName + \"Coadd\" + suffix","def fcvs(self): \n return self._link_reg.fcvs","def cdf(data_r, data_f, xlabel: str = 'Values', ylabel: str = 'Cumulative Sum', ax=None):\n x1 = np.sort(data_r)\n x2 = np.sort(data_f)\n y = np.arange(1, len(data_r) + 1) / len(data_r)\n\n ax = ax if ax else plt.subplots()[1]\n\n axis_font = {'size': '14'}\n ax.set_xlabel(xlabel, **axis_font)\n ax.set_ylabel(ylabel, **axis_font)\n\n ax.grid()\n ax.plot(x1, y, marker='o', linestyle='none', label='Real', ms=8)\n ax.plot(x2, y, marker='o', linestyle='none', label='Synthetic', alpha=0.5)\n ax.tick_params(axis='both', which='major', labelsize=8)\n ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.1), ncol=3)\n\n # If labels are strings, rotate them vertical\n if isinstance(data_r, pd.Series) and data_r.dtypes == 'object':\n ax.set_xticklabels(data_r.value_counts().sort_index().index, rotation='vertical')\n\n if ax is None:\n plt.show()","def cf(self):\n if hasattr(self, \"_cf_cache\"):\n return self._cf_cache\n return np.array([conf.cf for conf in self.configurations], dtype=int)","def crd(self):\r\n return self.__trajectory[0]","def getFactura(self): \n return self.caja","def getFactura(self): \n return self.caja","def _scfconv_from_ccdata(self):\n\n lines = [f\"scf-first 1 THROUGH {len(self.ccdata.scfenergies)}\"]\n\n for scfenergy in self.ccdata.scfenergies:\n lines.append(f\"{scfenergy:15.6f}\")\n\n return lines","def get_ctf(ima):\n\tfrom EMAN2 import EMAN2Ctf\n\tctf_params = ima.get_attr(\"ctf\")\t\n\treturn ctf_params.defocus, ctf_params.cs, ctf_params.voltage, ctf_params.apix, ctf_params.bfactor, ctf_params.ampcont, ctf_params.dfdiff, ctf_params.dfang","def getcfix(self):\n cfix_ = ctypes.c_double()\n res = __library__.MSK_XX_getcfix(self.__nativep,ctypes.byref(cfix_))\n if res != 0:\n _,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n cfix_ = cfix_.value\n _cfix_return_value = cfix_\n return (_cfix_return_value)","def c(self):\n if self.__c is not None:\n return self.__c\n else:\n raise ValueError(\"Run .fit() first!\")","def cdf(self,x):\n if self.functionType == 'cdf':\n cdfValue = self.cdfFunc(x)\n else:\n cdfValue = self.pdfFunc.integral(self.data[0][0],x)\n return cdfValue","def getcfix(self): # 3\n res,resargs = self.__obj.getcfix()\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n _cfix_return_value = resargs\n return _cfix_return_value","def get_crds_cc(self, axes=None, shaped=False):\n return self._src_crds.get_crds_cc(axes=axes, shaped=shaped)","def cdf(self, x):\n\n pi = 3.1415926536\n mean = self.mean\n stddev = self.stddev\n\n x1 = (x - mean) / (stddev * (2 ** 0.5))\n\n erf1 = (2/pi**0.5)\n erf2 = (x1-((x1**3)/3)+((x1**5)/10)-((x1**7)/42)+((x1**9)/216))\n erf = erf1 * erf2\n cdf = (1/2)*(1+erf)\n\n return cdf","def get_frequency(self):\r\n return self.f","def tocsc(self):\n return self.tocsr().tocsc()","def encoding_cctf(self):\n\n return self._encoding_cctf","def cfunc_type(self):\n tif = ida_typeinf.tinfo_t()\n result = self.get_func_type(tif)\n if not result:\n return\n return tif","def icdf(self, value):\n return self._normal.icdf(value)","def covar_samp(self):\n if self.count <= 1:\n return None\n return self.Ck / (self.count - 1)","def cdf(self,x):\n if self.base == 'natural':\n cdfValue = (math.log(x)-self.lowerBound)/(self.upperBound-self.lowerBound)\n else:\n cdfValue = (math.log10(x)-self.lowerBound)/(self.upperBound-self.lowerBound)\n return cdfValue","def get_cdt(self):\n return None if self.is_raw() else self.structure.compounddatatype","def get_crd_fc(self, axis, shaped=False):\n return self._src_crds.get_fc(axis, shaped=shaped)","def tcvs(self): \n return self._link_reg.tcvs","def _ref_dc(self):\n val_ref = self.meta[globals._ref_ds_attr]\n ref_dc = parse(globals._ds_short_name_attr, val_ref)[0]\n return ref_dc","def coherency(self):\r\n coherency = tsa.cache_to_coherency(self.cache, self.ij)\r\n\r\n return coherency","def dc_coupled(self):\n return self._dc_coupled","def getFunctionStyle(self,cpArray,X0):\n cpArray=tf.cast(tf.convert_to_tensor(cpArray),dtype=tf.float64)\n X0 = tf.cast(tf.convert_to_tensor(X0),dtype=tf.float64)\n func = self.lamda_computeCPdiff(X0)\n gatheredCps = tf.map_fn(func,cpArray,parallel_iterations=32,back_prop=False)\n return gatheredCps","def cdf(self,x):\n if hasattr(x,'__len__'):\n returnCdf = np.array([self.cdf(i) for i in x])\n else:\n returnCdf = self._distribution.cdf(x)\n return returnCdf","def cdf(self,x):\n sortedMapping = sorted(self.mapping.items(), key=operator.itemgetter(0))\n if x == sortedMapping[-1][0]:\n return 1.0\n if x in self.values:\n cumulative=0.0\n for element in sortedMapping:\n cumulative += element[1]\n if x == ( float(element[0]) if self.isFloat else element[0] ):\n return cumulative\n else:\n if self.isFloat:\n cumulative=0.0\n for element in sortedMapping:\n cumulative += element[1]\n if x >= element[0]:\n return cumulative\n # if we reach this point we must error out\n self.raiseAnError(IOError,'Categorical distribution cannot calculate cdf for ' + str(x))","def c(self):\n return self._c","def _df_reg(self):\n return self.k","def ctof(temp):\n return temp * 9/5 + 32 # functions should be surrounded by 2 blank lines","def coherency(time_series, csd_method=None):\r\n if csd_method is None:\r\n csd_method = {'this_method': 'welch'} # The default\r\n\r\n f, fxy = get_spectra(time_series, csd_method)\r\n\r\n #A container for the coherencys, with the size and shape of the expected\r\n #output:\r\n c = np.zeros((time_series.shape[0],\r\n time_series.shape[0],\r\n f.shape[0]), dtype=complex) # Make sure it's complex\r\n\r\n for i in range(time_series.shape[0]):\r\n for j in range(i, time_series.shape[0]):\r\n c[i][j] = coherency_spec(fxy[i][j], fxy[i][i], fxy[j][j])\r\n\r\n idx = tril_indices(time_series.shape[0], -1)\r\n c[idx[0], idx[1], ...] = c[idx[1], idx[0], ...].conj() # Make it symmetric\r\n\r\n return f, c","def c(self):\r\n return self.__c","def cdf(self,x):\n return self.categoricalDist.cdf(x)","def get_cfi(data):\n if data is None:\n raise EmptyDataError('[!] Invalid data value')\n\n result = TA.CFI(data)\n if result is None:\n raise IndicatorException\n return result","def get_fcc_level(self):\n raise NotImplementedError","def cactiStyle(requestContext, seriesList, system=None):\n if 0 == len(seriesList):\n return seriesList\n if system:\n fmt = lambda x:\"%.2f%s\" % format_units(x,system=system)\n else:\n fmt = lambda x:\"%.2f\"%x\n nameLen = max([0] + [len(getattr(series,\"name\")) for series in seriesList])\n lastLen = max([0] + [len(fmt(int(safeLast(series) or 3))) for series in seriesList]) + 3\n maxLen = max([0] + [len(fmt(int(safeMax(series) or 3))) for series in seriesList]) + 3\n minLen = max([0] + [len(fmt(int(safeMin(series) or 3))) for series in seriesList]) + 3\n for series in seriesList:\n name = series.name\n last = safeLast(series)\n maximum = safeMax(series)\n minimum = safeMin(series)\n if last is None:\n last = NAN\n else:\n last = fmt(float(last))\n\n if maximum is None:\n maximum = NAN\n else:\n maximum = fmt(float(maximum))\n if minimum is None:\n minimum = NAN\n else:\n minimum = fmt(float(minimum))\n\n series.name = \"%*s Current:%*s Max:%*s Min:%*s \" % \\\n (-nameLen, series.name,\n -lastLen, last,\n -maxLen, maximum,\n -minLen, minimum)\n return seriesList","def getScatteringSignal(self):\r\n\t\treturn self.scatData","def cdf(self,x):\n if self.method == 'spline':\n coordinate = distribution1D.vectord_cxx(len(x))\n for i in range(len(x)):\n coordinate[i] = x[i]\n cdfValue = self._distribution.cdf(coordinate)\n else:\n self.raiseAnError(NotImplementedError,'cdf not yet implemented for ' + self.method + ' method')\n return cdfValue","def getSeriesFK(self):\n return self.getDbRecord().getColumnValue(SERIES_COLUMN)","def scatters(self):\n\t\treturn self._scatter","def ct(self):\n return self._ct","def dc(self):\n return np.array(self['dc'], dtype=np.float32) / 1000","def n_cf(self):\n return self._configurations[0].n_cf","def get_covid_term() -> pd.DataFrame:\n return NOTICE_GETTER.term","def get_cb_model_freq():\n\talexander_orig_dr1 = 1361.25 * u.MHz\n\treturn alexander_orig_dr1","def cci(self) -> float:\n return self._cci","def cole_coeff(self):\n return self.diseq_coeff(standardize=True)","def get_series(series):\n if series == 'acs1':\n return census.acs1dp\n elif series == 'acs5':\n return census.acs5\n elif series == 'sf1':\n return census.sf1\n elif series == 'sf3':\n return census.sf3\n else:\n return None","def fiftyk_dac_num(self):\n return self._fiftyk_dac_num","def _get_concentration(self, state):\n return self.fc(state.float_features).exp() + self.EPSILON","def getCF(self):\r\n return self.lEq;","def csb(self):\n\n def myfunc(incident_energy):\n return XrayLibWrap_Energy(self.Z, \"csb\", incident_energy)\n\n return myfunc","def cdf(self, value):\n return self._normal.cdf(value)","def cdf(self, x, mu, **kwargs):\n if not hasattr(self, \"_cdfsample\"):\n # - just get it once\n self._cdfsample = self.rvs(mu, size=1e4, nsample=1e4)\n if is_arraylike(x):\n return np.asarray([float(len(self._cdfsample[self._cdfsample<x_]))/ 1e4\n for x_ in x])\n return float(len(self._cdfsample[self._cdfsample<x]))/ 1e4","def calculate_cdf(self):\n df_cdf = self.get_cdf_data()\n return ECDF(df_cdf['minute'])","def dcpl(self):\n # easy enough\n return self._dataset._pyre_id.dcpl","def getConversionFactor(self):\n return _libsbml.Species_getConversionFactor(self)","def cdf(self, x):\n\n if type(x) is np.float64:\n x = np.array([x])\n\n ndx = [np.argmin(np.abs(self.xs - x[i])) for i in range(x.size)]\n\n return self.ys[ndx]","def decoding_cctf(self):\n\n return self._decoding_cctf","def dc_data(self):\n return self._dc_data","def make_factor_source(series):\n return ColumnDataSource(data={'factors': series.unique()})","def fci(country_id: str, measure: _FCI_MEASURE = _FCI_MEASURE.FCI, *, source: str = None,\n real_time: bool = False, request_id: Optional[str] = None) -> pd.Series:\n if real_time:\n raise NotImplementedError('real-time FCI data is not available')\n\n type_ = QueryType(inflection.titleize(measure.value))\n if measure == _FCI_MEASURE.REAL_FCI or measure == _FCI_MEASURE.REAL_TWI_CONTRIBUTION:\n ds = Dataset('FCI')\n df = ds.get_data(geographyId=country_id)\n if measure == _FCI_MEASURE.REAL_FCI:\n measure = 'realFCI'\n else:\n measure = 'realTWIContribution'\n series = ExtendedSeries(dtype=float) if (measure not in df.columns) else ExtendedSeries(df[measure])\n series.dataset_ids = ('FCI',)\n return series\n\n q = GsDataApi.build_market_data_query([country_id], query_type=type_, source=source,\n real_time=real_time)\n df = _market_data_timed(q, request_id)\n return _extract_series_from_df(df, type_, True)","def get_icdf(self, xx):\n return self.parent.ppf(xx)","def get_viscous_cfl(discr, eos, dt, cv):\n return dt / get_viscous_timestep(discr, eos=eos, cv=cv)","def n_cs(self):\n pass","def ch_amount(self):\n return self.timeseries.shape[1]","def tc(self):\n return np.sum(self.tcs)","def cs(self):\n return self._cs","def reverse_CDF(self):\n self.series_y = 1. - self.series_y\n self.quantile_series_y_lower = 1. - self.quantile_series_y_lower\n self.quantile_series_y_upper = 1. - self.quantile_series_y_upper","def assemble_chart(self):\n return self.name","def component_type(self):\n return 'ct'","def getDataSetType(self):\n return self.__data_set_type__","def getCDFValue(self, value):\n cdfValue = self.cdfSample.get(value, None)\n if cdfValue != None:\n return cdfValue\n \n cdfValue = self.cdfFunction(value)\n self.cdfSample[value] = cdfValue\n return cdfValue","def cdf(self,x):\n coordinate = distribution1D.vectord_cxx(len(x))\n for i in range(len(x)):\n coordinate[i] = x[i]\n cdfValue = self._distribution.cdf(coordinate)\n return cdfValue","def cdf(self,x):\n coordinate = distribution1D.vectord_cxx(len(x))\n for i in range(len(x)):\n coordinate[i] = x[i]\n cdfValue = self._distribution.cdf(coordinate)\n return cdfValue","def cdf(self, x):\n from scipy.special import betainc\n sq_x = x * x\n return np.where(\n sq_x < 1., betainc(self.m / 2.0, self.n / 2.0, sq_x),\n np.ones_like(x))","def cs(self):\n\n def myfunc(incident_energy):\n return XrayLibWrap_Energy(self.Z, \"cs\", incident_energy)\n\n return myfunc","def cc(self):\n try:\n from scipy.sparse import cs_graph_components\n _, label = cs_graph_components(self.adjacency())\n except:\n pass\n lil = self.to_coo_matrix().tolil().rows.tolist()\n label = lil_cc(lil)\n return label","def second_category_axis(self):\n return self.container['second_category_axis']","def _get_traffic_class_cos(self):\n return self.__traffic_class_cos","def calculate(self):\n\n return self.confusion_matrix.fn","def __cnc(cls, sens_mv, we_c):\n if we_c is None:\n return None\n\n cnc = we_c / (sens_mv / 1000.0)\n\n # print(\"A4Datum__cnc: we_c:%s cnc:%f\" % (we_c, cnc), file=sys.stderr)\n\n return cnc","def df_reg(self):\n return self._df_reg","def cdf(self, alpha): #Plot empirical cfd with confidence interval\n x = self.x\n n = len(x)\n y = np.arange(1, n+1)/n\n \n #Computing confidence interval with the Dvoretzky–Kiefer–Wolfowitz method based on the empirical points\n F1 = []\n F2 = []\n for i in range(0, n):\n e = (((mt.log(2/alpha))/(2*n))**0.5) \n F1.append(y[i] - e)\n F2.append(y[i] + e) \n plt.plot(sorted(x), y, label='Empirical CDF')\n plt.plot(sorted(x), F1, linestyle='--', color='red', alpha = 0.8, lw = 0.9, label = 'Dvoretzky–Kiefer–Wolfowitz Confidence Bands')\n plt.plot(sorted(x), F2, linestyle='--', color='red', alpha = 0.8, lw = 0.9)\n plt.ylabel('Cumulative Distribution Function')\n plt.xlabel('Observed Data')\n plt.legend()\n plt.show()\n \n return(y)","def cf_profile(self):\n return self.gen_profile() / self.sam_sys_inputs['system_capacity']","def cf_profile(self):\n return self.gen_profile() / self.sam_sys_inputs['system_capacity']"],"string":"[\n \"def getCDF(self):\\n return self.cdfSample\",\n \"def CFL(self):\\n return self.__CFL\",\n \"def get_cffts(self):\\n return [\\n rfft(self.nx, self.dx, fft=self.tfft, ny=self.ny,\\n dy=self.dy).get_cfft(),\\n rfft(self.nx, self.dx, fft=self.efft, ny=self.ny,\\n dy=self.dy).get_cfft(),\\n rfft(self.nx, self.dx, fft=self.bfft, ny=self.ny,\\n dy=self.dy).get_cfft()\\n ]\",\n \"def cpf(self):\\n return self._cpf\",\n \"def get_cfft(self):\\n return self.get_rfft().get_cfft()\",\n \"def tctfdfc(x):\\n if isinstance(x,Fdf) :\\n pass\\n else : \\n x = Fdf.constant(x)\\n return x\",\n \"def get_crds_fc(self, axes=None, shaped=False):\\n return self._src_crds.get_crds_fc(axes=axes, shaped=shaped)\",\n \"def coherency(self):\\r\\n data = self.input.data\\r\\n tseries_length = data.shape[0]\\r\\n spectrum_length = self.spectrum.shape[-1]\\r\\n\\r\\n coherency = np.zeros((tseries_length,\\r\\n tseries_length,\\r\\n spectrum_length), dtype=complex)\\r\\n\\r\\n for i in range(tseries_length):\\r\\n for j in range(i, tseries_length):\\r\\n coherency[i][j] = tsa.coherency_spec(self.spectrum[i][j],\\r\\n self.spectrum[i][i],\\r\\n self.spectrum[j][j])\\r\\n\\r\\n idx = tril_indices(tseries_length, -1)\\r\\n coherency[idx[0], idx[1], ...] = coherency[idx[1], idx[0], ...].conj()\\r\\n\\r\\n return coherency\",\n \"def cdf(x, point):\\n raise NotImplementedError(\\\"The cdf method has not yet been implemented.\\\")\",\n \"def coherence(self):\\r\\n\\r\\n #XXX Calculate this from the standard output, instead of recalculating\\r\\n #the coherence:\\r\\n\\r\\n tseries_length = self.input.data.shape[0]\\r\\n spectrum_length = self.spectrum.shape[-1]\\r\\n coherence = np.zeros((tseries_length,\\r\\n tseries_length,\\r\\n spectrum_length))\\r\\n\\r\\n for i in range(tseries_length):\\r\\n for j in range(i, tseries_length):\\r\\n coherence[i][j] = tsa.coherence_spec(self.spectrum[i][j],\\r\\n self.spectrum[i][i],\\r\\n self.spectrum[j][j])\\r\\n\\r\\n idx = tril_indices(tseries_length, -1)\\r\\n coherence[idx[0], idx[1], ...] = coherence[idx[1], idx[0], ...].conj()\\r\\n\\r\\n return coherence\",\n \"def getCoaddDatasetName(self):\\n warpType = self.config.warpType\\n suffix = \\\"\\\" if warpType == \\\"direct\\\" else warpType[0].upper() + warpType[1:]\\n return self.config.coaddName + \\\"Coadd\\\" + suffix\",\n \"def fcvs(self): \\n return self._link_reg.fcvs\",\n \"def cdf(data_r, data_f, xlabel: str = 'Values', ylabel: str = 'Cumulative Sum', ax=None):\\n x1 = np.sort(data_r)\\n x2 = np.sort(data_f)\\n y = np.arange(1, len(data_r) + 1) / len(data_r)\\n\\n ax = ax if ax else plt.subplots()[1]\\n\\n axis_font = {'size': '14'}\\n ax.set_xlabel(xlabel, **axis_font)\\n ax.set_ylabel(ylabel, **axis_font)\\n\\n ax.grid()\\n ax.plot(x1, y, marker='o', linestyle='none', label='Real', ms=8)\\n ax.plot(x2, y, marker='o', linestyle='none', label='Synthetic', alpha=0.5)\\n ax.tick_params(axis='both', which='major', labelsize=8)\\n ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.1), ncol=3)\\n\\n # If labels are strings, rotate them vertical\\n if isinstance(data_r, pd.Series) and data_r.dtypes == 'object':\\n ax.set_xticklabels(data_r.value_counts().sort_index().index, rotation='vertical')\\n\\n if ax is None:\\n plt.show()\",\n \"def cf(self):\\n if hasattr(self, \\\"_cf_cache\\\"):\\n return self._cf_cache\\n return np.array([conf.cf for conf in self.configurations], dtype=int)\",\n \"def crd(self):\\r\\n return self.__trajectory[0]\",\n \"def getFactura(self): \\n return self.caja\",\n \"def getFactura(self): \\n return self.caja\",\n \"def _scfconv_from_ccdata(self):\\n\\n lines = [f\\\"scf-first 1 THROUGH {len(self.ccdata.scfenergies)}\\\"]\\n\\n for scfenergy in self.ccdata.scfenergies:\\n lines.append(f\\\"{scfenergy:15.6f}\\\")\\n\\n return lines\",\n \"def get_ctf(ima):\\n\\tfrom EMAN2 import EMAN2Ctf\\n\\tctf_params = ima.get_attr(\\\"ctf\\\")\\t\\n\\treturn ctf_params.defocus, ctf_params.cs, ctf_params.voltage, ctf_params.apix, ctf_params.bfactor, ctf_params.ampcont, ctf_params.dfdiff, ctf_params.dfang\",\n \"def getcfix(self):\\n cfix_ = ctypes.c_double()\\n res = __library__.MSK_XX_getcfix(self.__nativep,ctypes.byref(cfix_))\\n if res != 0:\\n _,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\\n cfix_ = cfix_.value\\n _cfix_return_value = cfix_\\n return (_cfix_return_value)\",\n \"def c(self):\\n if self.__c is not None:\\n return self.__c\\n else:\\n raise ValueError(\\\"Run .fit() first!\\\")\",\n \"def cdf(self,x):\\n if self.functionType == 'cdf':\\n cdfValue = self.cdfFunc(x)\\n else:\\n cdfValue = self.pdfFunc.integral(self.data[0][0],x)\\n return cdfValue\",\n \"def getcfix(self): # 3\\n res,resargs = self.__obj.getcfix()\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\\n _cfix_return_value = resargs\\n return _cfix_return_value\",\n \"def get_crds_cc(self, axes=None, shaped=False):\\n return self._src_crds.get_crds_cc(axes=axes, shaped=shaped)\",\n \"def cdf(self, x):\\n\\n pi = 3.1415926536\\n mean = self.mean\\n stddev = self.stddev\\n\\n x1 = (x - mean) / (stddev * (2 ** 0.5))\\n\\n erf1 = (2/pi**0.5)\\n erf2 = (x1-((x1**3)/3)+((x1**5)/10)-((x1**7)/42)+((x1**9)/216))\\n erf = erf1 * erf2\\n cdf = (1/2)*(1+erf)\\n\\n return cdf\",\n \"def get_frequency(self):\\r\\n return self.f\",\n \"def tocsc(self):\\n return self.tocsr().tocsc()\",\n \"def encoding_cctf(self):\\n\\n return self._encoding_cctf\",\n \"def cfunc_type(self):\\n tif = ida_typeinf.tinfo_t()\\n result = self.get_func_type(tif)\\n if not result:\\n return\\n return tif\",\n \"def icdf(self, value):\\n return self._normal.icdf(value)\",\n \"def covar_samp(self):\\n if self.count <= 1:\\n return None\\n return self.Ck / (self.count - 1)\",\n \"def cdf(self,x):\\n if self.base == 'natural':\\n cdfValue = (math.log(x)-self.lowerBound)/(self.upperBound-self.lowerBound)\\n else:\\n cdfValue = (math.log10(x)-self.lowerBound)/(self.upperBound-self.lowerBound)\\n return cdfValue\",\n \"def get_cdt(self):\\n return None if self.is_raw() else self.structure.compounddatatype\",\n \"def get_crd_fc(self, axis, shaped=False):\\n return self._src_crds.get_fc(axis, shaped=shaped)\",\n \"def tcvs(self): \\n return self._link_reg.tcvs\",\n \"def _ref_dc(self):\\n val_ref = self.meta[globals._ref_ds_attr]\\n ref_dc = parse(globals._ds_short_name_attr, val_ref)[0]\\n return ref_dc\",\n \"def coherency(self):\\r\\n coherency = tsa.cache_to_coherency(self.cache, self.ij)\\r\\n\\r\\n return coherency\",\n \"def dc_coupled(self):\\n return self._dc_coupled\",\n \"def getFunctionStyle(self,cpArray,X0):\\n cpArray=tf.cast(tf.convert_to_tensor(cpArray),dtype=tf.float64)\\n X0 = tf.cast(tf.convert_to_tensor(X0),dtype=tf.float64)\\n func = self.lamda_computeCPdiff(X0)\\n gatheredCps = tf.map_fn(func,cpArray,parallel_iterations=32,back_prop=False)\\n return gatheredCps\",\n \"def cdf(self,x):\\n if hasattr(x,'__len__'):\\n returnCdf = np.array([self.cdf(i) for i in x])\\n else:\\n returnCdf = self._distribution.cdf(x)\\n return returnCdf\",\n \"def cdf(self,x):\\n sortedMapping = sorted(self.mapping.items(), key=operator.itemgetter(0))\\n if x == sortedMapping[-1][0]:\\n return 1.0\\n if x in self.values:\\n cumulative=0.0\\n for element in sortedMapping:\\n cumulative += element[1]\\n if x == ( float(element[0]) if self.isFloat else element[0] ):\\n return cumulative\\n else:\\n if self.isFloat:\\n cumulative=0.0\\n for element in sortedMapping:\\n cumulative += element[1]\\n if x >= element[0]:\\n return cumulative\\n # if we reach this point we must error out\\n self.raiseAnError(IOError,'Categorical distribution cannot calculate cdf for ' + str(x))\",\n \"def c(self):\\n return self._c\",\n \"def _df_reg(self):\\n return self.k\",\n \"def ctof(temp):\\n return temp * 9/5 + 32 # functions should be surrounded by 2 blank lines\",\n \"def coherency(time_series, csd_method=None):\\r\\n if csd_method is None:\\r\\n csd_method = {'this_method': 'welch'} # The default\\r\\n\\r\\n f, fxy = get_spectra(time_series, csd_method)\\r\\n\\r\\n #A container for the coherencys, with the size and shape of the expected\\r\\n #output:\\r\\n c = np.zeros((time_series.shape[0],\\r\\n time_series.shape[0],\\r\\n f.shape[0]), dtype=complex) # Make sure it's complex\\r\\n\\r\\n for i in range(time_series.shape[0]):\\r\\n for j in range(i, time_series.shape[0]):\\r\\n c[i][j] = coherency_spec(fxy[i][j], fxy[i][i], fxy[j][j])\\r\\n\\r\\n idx = tril_indices(time_series.shape[0], -1)\\r\\n c[idx[0], idx[1], ...] = c[idx[1], idx[0], ...].conj() # Make it symmetric\\r\\n\\r\\n return f, c\",\n \"def c(self):\\r\\n return self.__c\",\n \"def cdf(self,x):\\n return self.categoricalDist.cdf(x)\",\n \"def get_cfi(data):\\n if data is None:\\n raise EmptyDataError('[!] Invalid data value')\\n\\n result = TA.CFI(data)\\n if result is None:\\n raise IndicatorException\\n return result\",\n \"def get_fcc_level(self):\\n raise NotImplementedError\",\n \"def cactiStyle(requestContext, seriesList, system=None):\\n if 0 == len(seriesList):\\n return seriesList\\n if system:\\n fmt = lambda x:\\\"%.2f%s\\\" % format_units(x,system=system)\\n else:\\n fmt = lambda x:\\\"%.2f\\\"%x\\n nameLen = max([0] + [len(getattr(series,\\\"name\\\")) for series in seriesList])\\n lastLen = max([0] + [len(fmt(int(safeLast(series) or 3))) for series in seriesList]) + 3\\n maxLen = max([0] + [len(fmt(int(safeMax(series) or 3))) for series in seriesList]) + 3\\n minLen = max([0] + [len(fmt(int(safeMin(series) or 3))) for series in seriesList]) + 3\\n for series in seriesList:\\n name = series.name\\n last = safeLast(series)\\n maximum = safeMax(series)\\n minimum = safeMin(series)\\n if last is None:\\n last = NAN\\n else:\\n last = fmt(float(last))\\n\\n if maximum is None:\\n maximum = NAN\\n else:\\n maximum = fmt(float(maximum))\\n if minimum is None:\\n minimum = NAN\\n else:\\n minimum = fmt(float(minimum))\\n\\n series.name = \\\"%*s Current:%*s Max:%*s Min:%*s \\\" % \\\\\\n (-nameLen, series.name,\\n -lastLen, last,\\n -maxLen, maximum,\\n -minLen, minimum)\\n return seriesList\",\n \"def getScatteringSignal(self):\\r\\n\\t\\treturn self.scatData\",\n \"def cdf(self,x):\\n if self.method == 'spline':\\n coordinate = distribution1D.vectord_cxx(len(x))\\n for i in range(len(x)):\\n coordinate[i] = x[i]\\n cdfValue = self._distribution.cdf(coordinate)\\n else:\\n self.raiseAnError(NotImplementedError,'cdf not yet implemented for ' + self.method + ' method')\\n return cdfValue\",\n \"def getSeriesFK(self):\\n return self.getDbRecord().getColumnValue(SERIES_COLUMN)\",\n \"def scatters(self):\\n\\t\\treturn self._scatter\",\n \"def ct(self):\\n return self._ct\",\n \"def dc(self):\\n return np.array(self['dc'], dtype=np.float32) / 1000\",\n \"def n_cf(self):\\n return self._configurations[0].n_cf\",\n \"def get_covid_term() -> pd.DataFrame:\\n return NOTICE_GETTER.term\",\n \"def get_cb_model_freq():\\n\\talexander_orig_dr1 = 1361.25 * u.MHz\\n\\treturn alexander_orig_dr1\",\n \"def cci(self) -> float:\\n return self._cci\",\n \"def cole_coeff(self):\\n return self.diseq_coeff(standardize=True)\",\n \"def get_series(series):\\n if series == 'acs1':\\n return census.acs1dp\\n elif series == 'acs5':\\n return census.acs5\\n elif series == 'sf1':\\n return census.sf1\\n elif series == 'sf3':\\n return census.sf3\\n else:\\n return None\",\n \"def fiftyk_dac_num(self):\\n return self._fiftyk_dac_num\",\n \"def _get_concentration(self, state):\\n return self.fc(state.float_features).exp() + self.EPSILON\",\n \"def getCF(self):\\r\\n return self.lEq;\",\n \"def csb(self):\\n\\n def myfunc(incident_energy):\\n return XrayLibWrap_Energy(self.Z, \\\"csb\\\", incident_energy)\\n\\n return myfunc\",\n \"def cdf(self, value):\\n return self._normal.cdf(value)\",\n \"def cdf(self, x, mu, **kwargs):\\n if not hasattr(self, \\\"_cdfsample\\\"):\\n # - just get it once\\n self._cdfsample = self.rvs(mu, size=1e4, nsample=1e4)\\n if is_arraylike(x):\\n return np.asarray([float(len(self._cdfsample[self._cdfsample<x_]))/ 1e4\\n for x_ in x])\\n return float(len(self._cdfsample[self._cdfsample<x]))/ 1e4\",\n \"def calculate_cdf(self):\\n df_cdf = self.get_cdf_data()\\n return ECDF(df_cdf['minute'])\",\n \"def dcpl(self):\\n # easy enough\\n return self._dataset._pyre_id.dcpl\",\n \"def getConversionFactor(self):\\n return _libsbml.Species_getConversionFactor(self)\",\n \"def cdf(self, x):\\n\\n if type(x) is np.float64:\\n x = np.array([x])\\n\\n ndx = [np.argmin(np.abs(self.xs - x[i])) for i in range(x.size)]\\n\\n return self.ys[ndx]\",\n \"def decoding_cctf(self):\\n\\n return self._decoding_cctf\",\n \"def dc_data(self):\\n return self._dc_data\",\n \"def make_factor_source(series):\\n return ColumnDataSource(data={'factors': series.unique()})\",\n \"def fci(country_id: str, measure: _FCI_MEASURE = _FCI_MEASURE.FCI, *, source: str = None,\\n real_time: bool = False, request_id: Optional[str] = None) -> pd.Series:\\n if real_time:\\n raise NotImplementedError('real-time FCI data is not available')\\n\\n type_ = QueryType(inflection.titleize(measure.value))\\n if measure == _FCI_MEASURE.REAL_FCI or measure == _FCI_MEASURE.REAL_TWI_CONTRIBUTION:\\n ds = Dataset('FCI')\\n df = ds.get_data(geographyId=country_id)\\n if measure == _FCI_MEASURE.REAL_FCI:\\n measure = 'realFCI'\\n else:\\n measure = 'realTWIContribution'\\n series = ExtendedSeries(dtype=float) if (measure not in df.columns) else ExtendedSeries(df[measure])\\n series.dataset_ids = ('FCI',)\\n return series\\n\\n q = GsDataApi.build_market_data_query([country_id], query_type=type_, source=source,\\n real_time=real_time)\\n df = _market_data_timed(q, request_id)\\n return _extract_series_from_df(df, type_, True)\",\n \"def get_icdf(self, xx):\\n return self.parent.ppf(xx)\",\n \"def get_viscous_cfl(discr, eos, dt, cv):\\n return dt / get_viscous_timestep(discr, eos=eos, cv=cv)\",\n \"def n_cs(self):\\n pass\",\n \"def ch_amount(self):\\n return self.timeseries.shape[1]\",\n \"def tc(self):\\n return np.sum(self.tcs)\",\n \"def cs(self):\\n return self._cs\",\n \"def reverse_CDF(self):\\n self.series_y = 1. - self.series_y\\n self.quantile_series_y_lower = 1. - self.quantile_series_y_lower\\n self.quantile_series_y_upper = 1. - self.quantile_series_y_upper\",\n \"def assemble_chart(self):\\n return self.name\",\n \"def component_type(self):\\n return 'ct'\",\n \"def getDataSetType(self):\\n return self.__data_set_type__\",\n \"def getCDFValue(self, value):\\n cdfValue = self.cdfSample.get(value, None)\\n if cdfValue != None:\\n return cdfValue\\n \\n cdfValue = self.cdfFunction(value)\\n self.cdfSample[value] = cdfValue\\n return cdfValue\",\n \"def cdf(self,x):\\n coordinate = distribution1D.vectord_cxx(len(x))\\n for i in range(len(x)):\\n coordinate[i] = x[i]\\n cdfValue = self._distribution.cdf(coordinate)\\n return cdfValue\",\n \"def cdf(self,x):\\n coordinate = distribution1D.vectord_cxx(len(x))\\n for i in range(len(x)):\\n coordinate[i] = x[i]\\n cdfValue = self._distribution.cdf(coordinate)\\n return cdfValue\",\n \"def cdf(self, x):\\n from scipy.special import betainc\\n sq_x = x * x\\n return np.where(\\n sq_x < 1., betainc(self.m / 2.0, self.n / 2.0, sq_x),\\n np.ones_like(x))\",\n \"def cs(self):\\n\\n def myfunc(incident_energy):\\n return XrayLibWrap_Energy(self.Z, \\\"cs\\\", incident_energy)\\n\\n return myfunc\",\n \"def cc(self):\\n try:\\n from scipy.sparse import cs_graph_components\\n _, label = cs_graph_components(self.adjacency())\\n except:\\n pass\\n lil = self.to_coo_matrix().tolil().rows.tolist()\\n label = lil_cc(lil)\\n return label\",\n \"def second_category_axis(self):\\n return self.container['second_category_axis']\",\n \"def _get_traffic_class_cos(self):\\n return self.__traffic_class_cos\",\n \"def calculate(self):\\n\\n return self.confusion_matrix.fn\",\n \"def __cnc(cls, sens_mv, we_c):\\n if we_c is None:\\n return None\\n\\n cnc = we_c / (sens_mv / 1000.0)\\n\\n # print(\\\"A4Datum__cnc: we_c:%s cnc:%f\\\" % (we_c, cnc), file=sys.stderr)\\n\\n return cnc\",\n \"def df_reg(self):\\n return self._df_reg\",\n \"def cdf(self, alpha): #Plot empirical cfd with confidence interval\\n x = self.x\\n n = len(x)\\n y = np.arange(1, n+1)/n\\n \\n #Computing confidence interval with the Dvoretzky–Kiefer–Wolfowitz method based on the empirical points\\n F1 = []\\n F2 = []\\n for i in range(0, n):\\n e = (((mt.log(2/alpha))/(2*n))**0.5) \\n F1.append(y[i] - e)\\n F2.append(y[i] + e) \\n plt.plot(sorted(x), y, label='Empirical CDF')\\n plt.plot(sorted(x), F1, linestyle='--', color='red', alpha = 0.8, lw = 0.9, label = 'Dvoretzky–Kiefer–Wolfowitz Confidence Bands')\\n plt.plot(sorted(x), F2, linestyle='--', color='red', alpha = 0.8, lw = 0.9)\\n plt.ylabel('Cumulative Distribution Function')\\n plt.xlabel('Observed Data')\\n plt.legend()\\n plt.show()\\n \\n return(y)\",\n \"def cf_profile(self):\\n return self.gen_profile() / self.sam_sys_inputs['system_capacity']\",\n \"def cf_profile(self):\\n return self.gen_profile() / self.sam_sys_inputs['system_capacity']\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6114998","0.5954782","0.5948087","0.5920047","0.59179395","0.58852816","0.5781732","0.57313186","0.57007056","0.56663144","0.5602908","0.5576217","0.55340517","0.5467268","0.5431777","0.539905","0.539905","0.5388791","0.5385939","0.53720737","0.53636706","0.53411496","0.5322548","0.5310017","0.5297604","0.52846134","0.5278062","0.52724767","0.52551216","0.52371514","0.5232755","0.5206213","0.52029634","0.51924735","0.5183661","0.5183041","0.5178247","0.5177974","0.51691633","0.51678383","0.5153432","0.51469266","0.5139363","0.5131394","0.51298964","0.5124347","0.5118544","0.5118314","0.51132095","0.51117074","0.5110755","0.50963557","0.50801843","0.5073414","0.50692683","0.50578475","0.50498366","0.50484073","0.5039423","0.50301564","0.5006748","0.50036377","0.49999183","0.4998922","0.49978065","0.49955595","0.4994862","0.49862435","0.49820098","0.49731013","0.49698755","0.4968734","0.4965747","0.49655133","0.4957994","0.49565908","0.49563527","0.49514169","0.49454102","0.49274433","0.49227017","0.49187818","0.49154907","0.4914583","0.49133956","0.49106553","0.48907107","0.48899338","0.48899338","0.48897523","0.48791623","0.48748165","0.4872317","0.48694846","0.48650694","0.4864046","0.48604745","0.48586187","0.48576757","0.48576757"],"string":"[\n \"0.6114998\",\n \"0.5954782\",\n \"0.5948087\",\n \"0.5920047\",\n \"0.59179395\",\n \"0.58852816\",\n \"0.5781732\",\n \"0.57313186\",\n \"0.57007056\",\n \"0.56663144\",\n \"0.5602908\",\n \"0.5576217\",\n \"0.55340517\",\n \"0.5467268\",\n \"0.5431777\",\n \"0.539905\",\n \"0.539905\",\n \"0.5388791\",\n \"0.5385939\",\n \"0.53720737\",\n \"0.53636706\",\n \"0.53411496\",\n \"0.5322548\",\n \"0.5310017\",\n \"0.5297604\",\n \"0.52846134\",\n \"0.5278062\",\n \"0.52724767\",\n \"0.52551216\",\n \"0.52371514\",\n \"0.5232755\",\n \"0.5206213\",\n \"0.52029634\",\n \"0.51924735\",\n \"0.5183661\",\n \"0.5183041\",\n \"0.5178247\",\n \"0.5177974\",\n \"0.51691633\",\n \"0.51678383\",\n \"0.5153432\",\n \"0.51469266\",\n \"0.5139363\",\n \"0.5131394\",\n \"0.51298964\",\n \"0.5124347\",\n \"0.5118544\",\n \"0.5118314\",\n \"0.51132095\",\n \"0.51117074\",\n \"0.5110755\",\n \"0.50963557\",\n \"0.50801843\",\n \"0.5073414\",\n \"0.50692683\",\n \"0.50578475\",\n \"0.50498366\",\n \"0.50484073\",\n \"0.5039423\",\n \"0.50301564\",\n \"0.5006748\",\n \"0.50036377\",\n \"0.49999183\",\n \"0.4998922\",\n \"0.49978065\",\n \"0.49955595\",\n \"0.4994862\",\n \"0.49862435\",\n \"0.49820098\",\n \"0.49731013\",\n \"0.49698755\",\n \"0.4968734\",\n \"0.4965747\",\n \"0.49655133\",\n \"0.4957994\",\n \"0.49565908\",\n \"0.49563527\",\n \"0.49514169\",\n \"0.49454102\",\n \"0.49274433\",\n \"0.49227017\",\n \"0.49187818\",\n \"0.49154907\",\n \"0.4914583\",\n \"0.49133956\",\n \"0.49106553\",\n \"0.48907107\",\n \"0.48899338\",\n \"0.48899338\",\n \"0.48897523\",\n \"0.48791623\",\n \"0.48748165\",\n \"0.4872317\",\n \"0.48694846\",\n \"0.48650694\",\n \"0.4864046\",\n \"0.48604745\",\n \"0.48586187\",\n \"0.48576757\",\n \"0.48576757\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5846474"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":94999,"cells":{"query":{"kind":"string","value":"Returns number of images in this data source."},"document":{"kind":"string","value":"def getNumberOfImages(self):\n\t\treturn self.numberOfImages"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_image_count(self):\n return self._num_images","def get_num_of_images(self):","def num_of_images(self):\n return len(self.data['image_infos'])","def numberOfImages(self):\n return len(self.imageList)","def __len__(self):\n return self.num_images","def __len__(self):\n return self.num_images","def __len__(self):\n return self.num_images","def __len__(self):\n return self.num_images","def __len__(self):\n return self.num_images","def count_images(self):\n\t\treturn self.session.query(Image.id).count()","def count(self):\n \n return len(self.img_lst)","def get_n_images(self) -> int:\n try:\n return self.header[\"NumberOfImagesInMosaic\"]\n except KeyError:\n raise KeyError(messages.MISSING_NUMBER_OF_IMAGES)","def getDataSetCount(self):\n\t\treturn int(self.numberOfImages / self.slicesPerTimepoint)","def size(self):\n\t\t\treturn len(self.image_ids)","def __len__(self):\n\n return len(self.images)","def __len__(self):\n return len(self.images)","def __len__(self):\n return len(self.images)","def __len__(self):\n return int(np.ceil(len(self.image_filenames) / (self.batch_size)))","def __len__(self):\n return len(self.db.list_nodes('/images'))","def __len__(self):\n return math.ceil(self.number_of_images / self.batch_size)","def _get_num_objects_per_step(self, worker_id=0):\n data_layer = self.get_data_layer(worker_id)\n num_images = tf.shape(data_layer.input_tensors['source_tensors'][0])[0]\n return num_images","def __len__(self) -> int:\n import h5py\n\n with h5py.File(\n os.path.join(self.root, self.data_dir, self.img_file_name), \"r\"\n ) as f:\n num_datapoints: int = f[self.split][\"pv_log\"].shape[0]\n\n return num_datapoints","def GetNumberOfMemoryImages(self):\r\n number = INT()\r\n r = CALL('GetNumberOfMemoryImages',self,INT(self.seq),byref(number))\r\n return self.CheckForSuccessError(r)","def __len__(self):\n return self.images.size(0)","def count(self):\n return self.data_container.count","def count(self):\r\n return self.data_array.size","def numPixels(self):\n self._logger.debug(\"numPixels\")\n return self.count","def getNumberPhoto(guide):\n return len(guide.photos.all())","def __len__(self):\n return len(self.imgs_path)","def __len__(self):\n\n return math.ceil(len(self.img_files) * self.gen_count / self.batch_size)","def n_images_acquired(self):\n n = ct.c_long()\n self.lib.GetTotalNumberImagesAcquired(ct.pointer(n))\n return n.value","def __len__(self):\n return len(self.image_paths)","def __len__(self):\n return len(self.image_paths)","def __len__(self):\n return len(self.image_paths)","def data_count(self):\n return(len(self.data))","def __len__(self):\n return len(self.image_file_names)","def get_num_eval_images(hparams):\n num_images_map = {\n 'imagenet': 50000,\n 'cifar10': 10000,\n }\n if hparams.input_data.input_fn not in num_images_map:\n raise ValueError(\n f'Unknown dataset size for input_fn {hparams.input_data.input_fn}')\n\n return num_images_map[hparams.input_data.input_fn]","def nb_im(self, code):\n return len(os.listdir(self._im_dir[code]))","def numPixels(self):\n\t\treturn self.size","def numPixels(self):\n\t\treturn self.size","def width(self) -> int:\n return self._image_data.width","def number_of_photos(self):\n return Submission.objects.filter(theme__contest=self).count()","def __len__(self):\n return len(self.img_paths)","def get_data_ninstances(self):\n return self.data_ninstances","def __len__(self):\n return len(self.image_names)","def count(self):\n return len(self.wallpapers)","def __len__(self):\n return self._dataset.size(dirs=self._dirs)","def dimension_count(self):\n return self._dimensionCount","def data_count(self):\r\n\r\n shp = self.df.shape\r\n row_count = shp[0]\r\n return row_count","def getNbRows(self):\n return self.data.shape[1]","def number_of_data_nodes(self):\n return int(self._data['number_of_data_nodes'])","def get_num_train_images(hparams):\n num_images_map = {\n 'imagenet': 1281167,\n 'cifar10': 50000,\n }\n if hparams.input_data.input_fn not in num_images_map:\n raise ValueError(\n f'Unknown dataset size for input_fn {hparams.input_data.input_fn}')\n\n num_images = num_images_map[hparams.input_data.input_fn]\n\n if hparams.input_data.max_samples > 0:\n return min(num_images, hparams.input_data.max_samples)\n return num_images","def getNeuronCount(self):\n\t\treturn self.loader.getNeuronCount()","def size(self):\n\t\treturn self._count","def __number_of_files(self):\n self.__get_files()\n return len(self.files)","def __len__(self):\r\n return len(self.img_names)","def file_count(self) -> int:\n if self.dataset is None:\n raise ValueError('No known dataset found!')\n return self._max_file_count","def __len__(self):\n return len(self.rimgdataset)","def num_sources(self):\n return len(self._sources)","def __len__( self ):\n return len( self._raster_data )","def getCount(self):\n return _osgAnimation.Target_getCount(self)","def max_scanned_images(self):\n return self._max_scanned_images","def getNumDimensions(self):\n return len(self.di.keys())","def getnrfiles(self):\n return len(self.filenames)","def getSampleCount(self):\r\n return len(self._data)","def __len__(self):\n # print(\"len: \" + str(math.floor(len([name for name in os.listdir(self.imgs_dir) if os.path.isfile(self.imgs_dir+'//'+name)])/self.batch_size)-1)\n return math.floor(len([name for name in os.listdir(self.imgs_dir) if\n os.path.isfile(self.imgs_dir + '//' + name)]) / self.batch_size)","def count_data(self):\n try:\n ndata = len(self.x)\n logger.info(\"Number of data points: {0}\".format(ndata))\n except AttributeError:\n logger.error(\"Data object has not been defined\")\n ndata = 0\n return ndata","def getNumRows(self) -> int:\n ...","def count(self):\n return self.size()","def num_entries(self):\r\n raise NotImplementedError('BaseDataSource::num_entries not specified.')","def getNumData(self):\n return len(self.data)","def num_rows(self) -> str:\n return pulumi.get(self, \"num_rows\")","def GetNumberOfObjects(self) -> \"unsigned long long\":\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterIUS3ISS3_GetNumberOfObjects(self)","def count(self):\n self._fetch_if_needed()\n return len(self._result_cache.get('rows', []))","def GetNumberOfObjects(self) -> \"unsigned long long\":\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterISS3IUS3_GetNumberOfObjects(self)","def size(self):\n ret = 0\n for ii in self.__data:\n ret += int(ii.get_size())\n return ret","def height(self) -> int:\n return self._image_data.height","def GetNumberOfObjects(self) -> \"unsigned long long\":\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterIUS3IUS3_GetNumberOfObjects(self)","def count(self) -> int:\n return self._adapter.count()","def dataset_size(self):\n if not self._dataset_size:\n # pylint: disable=attribute-defined-outside-init\n self._dataset_size = count_file_lines(\n self._hparams.source_dataset.files)\n return self._dataset_size","def getNrEntries(self):\n return len(self.data)","def getNumTiles(self):\n return (self.width) * (self.height)","async def totalImages(self, tags):\n with async_timeout.timeout(10):\n url = self.urlGen(tags=tags, PID=0)\n async with self.session.get(url=url) as XMLData:\n XMLData = await XMLData.read()\n XMLData = ET.XML(XMLData)\n XML = self.ParseXML(XMLData)\n return int(XML['posts']['@count'])\n return None","def GetNumberOfObjects(self) -> \"unsigned long long\":\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterIF3IUS3_GetNumberOfObjects(self)","def GetNumberOfObjects(self) -> \"unsigned long long\":\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterIUS2ISS2_GetNumberOfObjects(self)","def __len__(self):\n return len(self.image_info)","def __len__(self):\n return len(self.image_info)","def getNumTiles(self):\n return self.height * self.width","def getNumRows(self):\n return self.__rows","def _get_image_dimensions(self):\n\t\timageWidth = int(self.labels['IMAGE']['LINE_SAMPLES'])\n\t\timageHeight = int(self.labels['IMAGE']['LINES'])\n\t\treturn imageWidth, imageHeight","def numberFiles(self):\n return self.n","def get_data_dimensions(self):\n return image_utils.convert_shape_indexing(self._get_data_dimensions_rc(),\"rc\",self.image_indexing)","def band_count(self):\n return self.dataset.RasterCount if self.dataset else None","def GetNumberOfObjects(self) -> \"unsigned long long\":\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterISS3ISS3_GetNumberOfObjects(self)","def GetNumberOfObjects(self) -> \"unsigned long long\":\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterIF3ISS3_GetNumberOfObjects(self)","def nsim(self):\n return len(self)","def get_count(self):\n\n\t\treturn self.__count","def get_num_records(self):\n return self.__num_records","def count(self):\n return len(self.read_ints())","def voxel_count(self):\n return self.cols * self.rows * self.sections"],"string":"[\n \"def get_image_count(self):\\n return self._num_images\",\n \"def get_num_of_images(self):\",\n \"def num_of_images(self):\\n return len(self.data['image_infos'])\",\n \"def numberOfImages(self):\\n return len(self.imageList)\",\n \"def __len__(self):\\n return self.num_images\",\n \"def __len__(self):\\n return self.num_images\",\n \"def __len__(self):\\n return self.num_images\",\n \"def __len__(self):\\n return self.num_images\",\n \"def __len__(self):\\n return self.num_images\",\n \"def count_images(self):\\n\\t\\treturn self.session.query(Image.id).count()\",\n \"def count(self):\\n \\n return len(self.img_lst)\",\n \"def get_n_images(self) -> int:\\n try:\\n return self.header[\\\"NumberOfImagesInMosaic\\\"]\\n except KeyError:\\n raise KeyError(messages.MISSING_NUMBER_OF_IMAGES)\",\n \"def getDataSetCount(self):\\n\\t\\treturn int(self.numberOfImages / self.slicesPerTimepoint)\",\n \"def size(self):\\n\\t\\t\\treturn len(self.image_ids)\",\n \"def __len__(self):\\n\\n return len(self.images)\",\n \"def __len__(self):\\n return len(self.images)\",\n \"def __len__(self):\\n return len(self.images)\",\n \"def __len__(self):\\n return int(np.ceil(len(self.image_filenames) / (self.batch_size)))\",\n \"def __len__(self):\\n return len(self.db.list_nodes('/images'))\",\n \"def __len__(self):\\n return math.ceil(self.number_of_images / self.batch_size)\",\n \"def _get_num_objects_per_step(self, worker_id=0):\\n data_layer = self.get_data_layer(worker_id)\\n num_images = tf.shape(data_layer.input_tensors['source_tensors'][0])[0]\\n return num_images\",\n \"def __len__(self) -> int:\\n import h5py\\n\\n with h5py.File(\\n os.path.join(self.root, self.data_dir, self.img_file_name), \\\"r\\\"\\n ) as f:\\n num_datapoints: int = f[self.split][\\\"pv_log\\\"].shape[0]\\n\\n return num_datapoints\",\n \"def GetNumberOfMemoryImages(self):\\r\\n number = INT()\\r\\n r = CALL('GetNumberOfMemoryImages',self,INT(self.seq),byref(number))\\r\\n return self.CheckForSuccessError(r)\",\n \"def __len__(self):\\n return self.images.size(0)\",\n \"def count(self):\\n return self.data_container.count\",\n \"def count(self):\\r\\n return self.data_array.size\",\n \"def numPixels(self):\\n self._logger.debug(\\\"numPixels\\\")\\n return self.count\",\n \"def getNumberPhoto(guide):\\n return len(guide.photos.all())\",\n \"def __len__(self):\\n return len(self.imgs_path)\",\n \"def __len__(self):\\n\\n return math.ceil(len(self.img_files) * self.gen_count / self.batch_size)\",\n \"def n_images_acquired(self):\\n n = ct.c_long()\\n self.lib.GetTotalNumberImagesAcquired(ct.pointer(n))\\n return n.value\",\n \"def __len__(self):\\n return len(self.image_paths)\",\n \"def __len__(self):\\n return len(self.image_paths)\",\n \"def __len__(self):\\n return len(self.image_paths)\",\n \"def data_count(self):\\n return(len(self.data))\",\n \"def __len__(self):\\n return len(self.image_file_names)\",\n \"def get_num_eval_images(hparams):\\n num_images_map = {\\n 'imagenet': 50000,\\n 'cifar10': 10000,\\n }\\n if hparams.input_data.input_fn not in num_images_map:\\n raise ValueError(\\n f'Unknown dataset size for input_fn {hparams.input_data.input_fn}')\\n\\n return num_images_map[hparams.input_data.input_fn]\",\n \"def nb_im(self, code):\\n return len(os.listdir(self._im_dir[code]))\",\n \"def numPixels(self):\\n\\t\\treturn self.size\",\n \"def numPixels(self):\\n\\t\\treturn self.size\",\n \"def width(self) -> int:\\n return self._image_data.width\",\n \"def number_of_photos(self):\\n return Submission.objects.filter(theme__contest=self).count()\",\n \"def __len__(self):\\n return len(self.img_paths)\",\n \"def get_data_ninstances(self):\\n return self.data_ninstances\",\n \"def __len__(self):\\n return len(self.image_names)\",\n \"def count(self):\\n return len(self.wallpapers)\",\n \"def __len__(self):\\n return self._dataset.size(dirs=self._dirs)\",\n \"def dimension_count(self):\\n return self._dimensionCount\",\n \"def data_count(self):\\r\\n\\r\\n shp = self.df.shape\\r\\n row_count = shp[0]\\r\\n return row_count\",\n \"def getNbRows(self):\\n return self.data.shape[1]\",\n \"def number_of_data_nodes(self):\\n return int(self._data['number_of_data_nodes'])\",\n \"def get_num_train_images(hparams):\\n num_images_map = {\\n 'imagenet': 1281167,\\n 'cifar10': 50000,\\n }\\n if hparams.input_data.input_fn not in num_images_map:\\n raise ValueError(\\n f'Unknown dataset size for input_fn {hparams.input_data.input_fn}')\\n\\n num_images = num_images_map[hparams.input_data.input_fn]\\n\\n if hparams.input_data.max_samples > 0:\\n return min(num_images, hparams.input_data.max_samples)\\n return num_images\",\n \"def getNeuronCount(self):\\n\\t\\treturn self.loader.getNeuronCount()\",\n \"def size(self):\\n\\t\\treturn self._count\",\n \"def __number_of_files(self):\\n self.__get_files()\\n return len(self.files)\",\n \"def __len__(self):\\r\\n return len(self.img_names)\",\n \"def file_count(self) -> int:\\n if self.dataset is None:\\n raise ValueError('No known dataset found!')\\n return self._max_file_count\",\n \"def __len__(self):\\n return len(self.rimgdataset)\",\n \"def num_sources(self):\\n return len(self._sources)\",\n \"def __len__( self ):\\n return len( self._raster_data )\",\n \"def getCount(self):\\n return _osgAnimation.Target_getCount(self)\",\n \"def max_scanned_images(self):\\n return self._max_scanned_images\",\n \"def getNumDimensions(self):\\n return len(self.di.keys())\",\n \"def getnrfiles(self):\\n return len(self.filenames)\",\n \"def getSampleCount(self):\\r\\n return len(self._data)\",\n \"def __len__(self):\\n # print(\\\"len: \\\" + str(math.floor(len([name for name in os.listdir(self.imgs_dir) if os.path.isfile(self.imgs_dir+'//'+name)])/self.batch_size)-1)\\n return math.floor(len([name for name in os.listdir(self.imgs_dir) if\\n os.path.isfile(self.imgs_dir + '//' + name)]) / self.batch_size)\",\n \"def count_data(self):\\n try:\\n ndata = len(self.x)\\n logger.info(\\\"Number of data points: {0}\\\".format(ndata))\\n except AttributeError:\\n logger.error(\\\"Data object has not been defined\\\")\\n ndata = 0\\n return ndata\",\n \"def getNumRows(self) -> int:\\n ...\",\n \"def count(self):\\n return self.size()\",\n \"def num_entries(self):\\r\\n raise NotImplementedError('BaseDataSource::num_entries not specified.')\",\n \"def getNumData(self):\\n return len(self.data)\",\n \"def num_rows(self) -> str:\\n return pulumi.get(self, \\\"num_rows\\\")\",\n \"def GetNumberOfObjects(self) -> \\\"unsigned long long\\\":\\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterIUS3ISS3_GetNumberOfObjects(self)\",\n \"def count(self):\\n self._fetch_if_needed()\\n return len(self._result_cache.get('rows', []))\",\n \"def GetNumberOfObjects(self) -> \\\"unsigned long long\\\":\\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterISS3IUS3_GetNumberOfObjects(self)\",\n \"def size(self):\\n ret = 0\\n for ii in self.__data:\\n ret += int(ii.get_size())\\n return ret\",\n \"def height(self) -> int:\\n return self._image_data.height\",\n \"def GetNumberOfObjects(self) -> \\\"unsigned long long\\\":\\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterIUS3IUS3_GetNumberOfObjects(self)\",\n \"def count(self) -> int:\\n return self._adapter.count()\",\n \"def dataset_size(self):\\n if not self._dataset_size:\\n # pylint: disable=attribute-defined-outside-init\\n self._dataset_size = count_file_lines(\\n self._hparams.source_dataset.files)\\n return self._dataset_size\",\n \"def getNrEntries(self):\\n return len(self.data)\",\n \"def getNumTiles(self):\\n return (self.width) * (self.height)\",\n \"async def totalImages(self, tags):\\n with async_timeout.timeout(10):\\n url = self.urlGen(tags=tags, PID=0)\\n async with self.session.get(url=url) as XMLData:\\n XMLData = await XMLData.read()\\n XMLData = ET.XML(XMLData)\\n XML = self.ParseXML(XMLData)\\n return int(XML['posts']['@count'])\\n return None\",\n \"def GetNumberOfObjects(self) -> \\\"unsigned long long\\\":\\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterIF3IUS3_GetNumberOfObjects(self)\",\n \"def GetNumberOfObjects(self) -> \\\"unsigned long long\\\":\\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterIUS2ISS2_GetNumberOfObjects(self)\",\n \"def __len__(self):\\n return len(self.image_info)\",\n \"def __len__(self):\\n return len(self.image_info)\",\n \"def getNumTiles(self):\\n return self.height * self.width\",\n \"def getNumRows(self):\\n return self.__rows\",\n \"def _get_image_dimensions(self):\\n\\t\\timageWidth = int(self.labels['IMAGE']['LINE_SAMPLES'])\\n\\t\\timageHeight = int(self.labels['IMAGE']['LINES'])\\n\\t\\treturn imageWidth, imageHeight\",\n \"def numberFiles(self):\\n return self.n\",\n \"def get_data_dimensions(self):\\n return image_utils.convert_shape_indexing(self._get_data_dimensions_rc(),\\\"rc\\\",self.image_indexing)\",\n \"def band_count(self):\\n return self.dataset.RasterCount if self.dataset else None\",\n \"def GetNumberOfObjects(self) -> \\\"unsigned long long\\\":\\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterISS3ISS3_GetNumberOfObjects(self)\",\n \"def GetNumberOfObjects(self) -> \\\"unsigned long long\\\":\\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterIF3ISS3_GetNumberOfObjects(self)\",\n \"def nsim(self):\\n return len(self)\",\n \"def get_count(self):\\n\\n\\t\\treturn self.__count\",\n \"def get_num_records(self):\\n return self.__num_records\",\n \"def count(self):\\n return len(self.read_ints())\",\n \"def voxel_count(self):\\n return self.cols * self.rows * self.sections\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.84259796","0.83975625","0.83702207","0.80581206","0.77916324","0.77916324","0.77916324","0.77916324","0.77916324","0.77843183","0.7672272","0.7612054","0.74140126","0.7412375","0.72965276","0.7274649","0.7274649","0.72326416","0.72228235","0.7218599","0.70864445","0.708459","0.70683193","0.7059244","0.69326055","0.68178713","0.68022555","0.6799224","0.6784809","0.672149","0.6714932","0.6709631","0.6709631","0.6709631","0.66932553","0.66850114","0.66800624","0.6673351","0.6670925","0.6670925","0.666576","0.66079414","0.6593638","0.65874344","0.65594745","0.65571356","0.6538444","0.6503468","0.64994514","0.6495293","0.64683235","0.6468276","0.6465324","0.64622283","0.6455188","0.6454062","0.6446032","0.64350474","0.6434601","0.64269894","0.6423044","0.6415868","0.6402428","0.6398995","0.63773715","0.637591","0.63552314","0.6350531","0.633134","0.6326437","0.6321258","0.6320779","0.63159865","0.6315664","0.63123333","0.63069254","0.63001543","0.62974346","0.6296235","0.6294599","0.629305","0.62883407","0.6288087","0.62861985","0.6283187","0.62821525","0.62821525","0.6281817","0.62785566","0.6265037","0.6259835","0.62595475","0.6254175","0.62541527","0.62522084","0.62486404","0.6243422","0.62416446","0.62396556","0.62332577"],"string":"[\n \"0.84259796\",\n \"0.83975625\",\n \"0.83702207\",\n \"0.80581206\",\n \"0.77916324\",\n \"0.77916324\",\n \"0.77916324\",\n \"0.77916324\",\n \"0.77916324\",\n \"0.77843183\",\n \"0.7672272\",\n \"0.7612054\",\n \"0.74140126\",\n \"0.7412375\",\n \"0.72965276\",\n \"0.7274649\",\n \"0.7274649\",\n \"0.72326416\",\n \"0.72228235\",\n \"0.7218599\",\n \"0.70864445\",\n \"0.708459\",\n \"0.70683193\",\n \"0.7059244\",\n \"0.69326055\",\n \"0.68178713\",\n \"0.68022555\",\n \"0.6799224\",\n \"0.6784809\",\n \"0.672149\",\n \"0.6714932\",\n \"0.6709631\",\n \"0.6709631\",\n \"0.6709631\",\n \"0.66932553\",\n \"0.66850114\",\n \"0.66800624\",\n \"0.6673351\",\n \"0.6670925\",\n \"0.6670925\",\n \"0.666576\",\n \"0.66079414\",\n \"0.6593638\",\n \"0.65874344\",\n \"0.65594745\",\n \"0.65571356\",\n \"0.6538444\",\n \"0.6503468\",\n \"0.64994514\",\n \"0.6495293\",\n \"0.64683235\",\n \"0.6468276\",\n \"0.6465324\",\n \"0.64622283\",\n \"0.6455188\",\n \"0.6454062\",\n \"0.6446032\",\n \"0.64350474\",\n \"0.6434601\",\n \"0.64269894\",\n \"0.6423044\",\n \"0.6415868\",\n \"0.6402428\",\n \"0.6398995\",\n \"0.63773715\",\n \"0.637591\",\n \"0.63552314\",\n \"0.6350531\",\n \"0.633134\",\n \"0.6326437\",\n \"0.6321258\",\n \"0.6320779\",\n \"0.63159865\",\n \"0.6315664\",\n \"0.63123333\",\n \"0.63069254\",\n \"0.63001543\",\n \"0.62974346\",\n \"0.6296235\",\n \"0.6294599\",\n \"0.629305\",\n \"0.62883407\",\n \"0.6288087\",\n \"0.62861985\",\n \"0.6283187\",\n \"0.62821525\",\n \"0.62821525\",\n \"0.6281817\",\n \"0.62785566\",\n \"0.6265037\",\n \"0.6259835\",\n \"0.62595475\",\n \"0.6254175\",\n \"0.62541527\",\n \"0.62522084\",\n \"0.62486404\",\n \"0.6243422\",\n \"0.62416446\",\n \"0.62396556\",\n \"0.62332577\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.85196555"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":949,"numItemsPerPage":100,"numTotalItems":95772,"offset":94900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NjE5MTE1MSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzYxOTQ3NTEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.xuS74Oy7S7ruFsGkJyvJV63UcXynH2s7ONwnbqhzVsfpjQ5cQoycSxI8ApLbwBw2DevFonqrztWZWG1yiBStCA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Zoom in on a specific station on a map | def station_on_map(request, station_number):
data_stations = stations_with_data()
station_number = int(station_number)
down, problem, up = status_lists()
station = get_object_or_404(Station, number=station_number)
center = station.latest_location()
if center['latitude'] is None and center['lon... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def zoom_to(self):\n # Will seek user feedback. QGIS will\n # Pan to first layer loaded",
"def zoomIn(self, x, y):\n\n # set view state\n (map_x, map_y) = self.getMapCoordsFromView((x,y))\n self.view_offset_x = map_x*2 - self.view_width/2\n self.view_offset_y = map_y*2 -... | [
"0.62788576",
"0.6039453",
"0.58890414",
"0.58117414",
"0.5672202",
"0.5654756",
"0.56279266",
"0.55998397",
"0.55568296",
"0.55527616",
"0.5512002",
"0.54508984",
"0.5449918",
"0.5449918",
"0.5449918",
"0.5449918",
"0.54433745",
"0.54276776",
"0.5427263",
"0.53882915",
"0.53... | 0.6076124 | 1 |
Show all stations from a subcluster on a map | def stations_on_map(request, country=None, cluster=None, subcluster=None):
data_stations = stations_with_data()
down, problem, up = status_lists()
if country:
get_object_or_404(Country, name=country)
if cluster:
get_object_or_404(Cluster, name=cluster, parent=None,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def station_on_map(request, station_number):\n\n data_stations = stations_with_data()\n station_number = int(station_number)\n down, problem, up = status_lists()\n\n station = get_object_or_404(Station, number=station_number)\n center = station.latest_location()\n if center['latitude'] is None an... | [
"0.67217124",
"0.6456021",
"0.6094351",
"0.59413135",
"0.57239014",
"0.56707394",
"0.5667912",
"0.5660193",
"0.56526005",
"0.56276786",
"0.5618511",
"0.56184906",
"0.5581086",
"0.55698586",
"0.5552247",
"0.5542267",
"0.5477948",
"0.5476224",
"0.54496205",
"0.5442602",
"0.5442... | 0.7505736 | 0 |
Helper shortcut for creating subcommands. Accepts arguments for `add_subparsers`, creating a new subparser and returning a partial function wrapping `add_subcommand` for the new subparser. If the `dest` argument isn't specified, it defaults to `'subcmd'`. Example cmd_foo = CommandParser('foo', 'Does foo stuff') foo_add... | def make_adder(self, *args, **kwargs):
kwargs.setdefault("dest", "subcmd")
subp = self.add_subparsers(*args, **kwargs)
return partial(self.add_subcommand, subp) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def subcommand(self, func=None, **subcommand_options):\n\n def decorator(subcommand_func):\n subcommand_sig = inspect.signature(subcommand_func)\n\n @functools.wraps(subcommand_func)\n def wrapped(args):\n\n final_args = []\n final_kwargs = {}\n... | [
"0.7137559",
"0.6991422",
"0.69432056",
"0.6767474",
"0.66648597",
"0.6645159",
"0.6587919",
"0.6517023",
"0.6504958",
"0.6392979",
"0.6344873",
"0.63118166",
"0.623115",
"0.62270325",
"0.62064266",
"0.6119958",
"0.61081535",
"0.60894066",
"0.60719246",
"0.6052931",
"0.600301... | 0.84089714 | 0 |
Helper method for adding subcommands. Wrapper around `add_parser` that simplifies adding subcommands to ZeroBot commands. The same string is used for both the `description` and `help` parameters of `add_parser`. | def add_subcommand(
subp: _SubParsersAction, name: str, description: Optional[str] = None, **kwargs
) -> "CommandParser":
desc_help = {"description": description, "help": description}
return subp.add_parser(name, **desc_help, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_subcommands(cls, parser: argparse.ArgumentParser) -> None:\n if cls.SUBCOMMANDS:\n subparsers = parser.add_subparsers(title=\"subcommands\", metavar=\"\", dest='cmd')\n for subcmd_class in cls.SUBCOMMANDS:\n parsers = subcmd_class.get_args()\n subc... | [
"0.76693493",
"0.7625279",
"0.761014",
"0.74660397",
"0.7304024",
"0.7300243",
"0.6937958",
"0.687252",
"0.6824965",
"0.68249416",
"0.6797736",
"0.6796231",
"0.67945975",
"0.6792037",
"0.6770885",
"0.67248243",
"0.6711912",
"0.66614723",
"0.6639564",
"0.66390103",
"0.6635527"... | 0.81267315 | 0 |
The module that this command is registered to. Will return `None` if this command has not yet been registered. | def module(self) -> Optional[Module]:
return self._module | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_module(self):\n return self.module",
"def module(self):\n return self._module",
"def module(self):\n return self._module",
"def module(self):\n return self._module",
"def module(self):\n return self._module",
"def module(self):\n return self._module",
"... | [
"0.8003115",
"0.7536935",
"0.7536935",
"0.7536935",
"0.7536935",
"0.7536935",
"0.75261885",
"0.7365347",
"0.70169824",
"0.68556315",
"0.67025244",
"0.66628325",
"0.66449714",
"0.6640801",
"0.6626384",
"0.652614",
"0.6519318",
"0.648883",
"0.64871985",
"0.64552623",
"0.6444489... | 0.74596643 | 7 |
The User that invoked the command. | def invoker(self) -> User:
return self.msg.source | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user(self):\n return self.getattr('user')",
"def user(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"user\")",
"def user(self) -> Optional[str]:\n _args: list[Arg] = []\n _ctx = self._select(\"user\", _args)\n return _ctx.execute_sync(Optional[str])",
"def use... | [
"0.80029744",
"0.78830194",
"0.7869089",
"0.7831611",
"0.7831611",
"0.7831611",
"0.7831611",
"0.7830656",
"0.77808654",
"0.77667016",
"0.77667016",
"0.77667016",
"0.7764792",
"0.77462137",
"0.7722865",
"0.7709639",
"0.77054626",
"0.77054626",
"0.7655964",
"0.7575146",
"0.7570... | 0.74655455 | 22 |
Where the command was sent from. Can be either directly from a user, or from a user within a channel. | def source(self) -> Union[User, Channel]:
return self.msg.destination | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def whoami( self, mess, args):\n return mess.getFrom()",
"def whoami(self, mess, args):\n return mess.getFrom().getStripped()",
"def invoker(self) -> User:\n return self.msg.source",
"def getFromUser(self):\n return self.fromUser",
"def reply_to(self):\n return self.recei... | [
"0.7382036",
"0.6963548",
"0.6660693",
"0.6343135",
"0.62228334",
"0.6178447",
"0.6127587",
"0.61155206",
"0.6074623",
"0.60027945",
"0.59703183",
"0.59151745",
"0.5872834",
"0.58546007",
"0.5829677",
"0.5820818",
"0.5783627",
"0.5776797",
"0.57764834",
"0.5776311",
"0.577293... | 0.6407649 | 3 |
The invoked subcommand name, if one was invoked. For subcommands with aliases, the name returned is always the canonical name that the aliases are associated with. For this reason, this attribute should be preferred to extracting the subcommand name from `ParsedCommand.args`. | def subcmd(self) -> Optional[str]:
return self._subcmd | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def command_name(self):\n return None",
"def get_commandname(self):\n for line in self.helplines:\n if \"Usage:\" in line and self.parser_type is 'optparse':\n tmp = line.split()\n return tmp[1]\n if \"usage:\" in line and self.parser_type is 'arg... | [
"0.6581749",
"0.6499524",
"0.6446358",
"0.6352551",
"0.6317428",
"0.62414986",
"0.6189401",
"0.6147004",
"0.6130716",
"0.61187094",
"0.60870796",
"0.60323155",
"0.5961086",
"0.5867416",
"0.5867416",
"0.5861084",
"0.58426297",
"0.58400583",
"0.5821133",
"0.58019865",
"0.579916... | 0.6821528 | 0 |
Get the name of a nested subcommand. Like the `subcmd` property, the name returned is always the canonical name for the subcommand. The `depth` parameter determines how many levels of nesting to traverse; the default of ``2`` gets the first nested subcommand. As a consequence, a value of ``1`` is the same as `subcmd`. | def nested_subcmd(self, depth: int = 2) -> Optional[str]:
# pylint: disable=protected-access
current = 0
subparser = self.parser
try:
while current < depth:
action = subparser._actions[0]
if isinstance(action, _SubParsersAction):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_subcmd(self, name: str) -> \"CommandHelp\":\n try:\n return self.subcmds[name]\n except KeyError:\n # Try looking up by alias\n for sub_name, sub_help in self.subcmds.items():\n for alias in sub_help.aliases:\n if name == alia... | [
"0.61825335",
"0.5816208",
"0.57917714",
"0.5630253",
"0.55556434",
"0.55294657",
"0.54540044",
"0.5216835",
"0.5201424",
"0.49779016",
"0.49343693",
"0.48652846",
"0.48608866",
"0.48450202",
"0.4835011",
"0.47898704",
"0.47898704",
"0.47851962",
"0.476425",
"0.472209",
"0.47... | 0.80556154 | 0 |
Get the `CommandHelp` object for the given subcommand. `name` may be an alias, in which case it is resolved to the appropriate subcommand. | def get_subcmd(self, name: str) -> "CommandHelp":
try:
return self.subcmds[name]
except KeyError:
# Try looking up by alias
for sub_name, sub_help in self.subcmds.items():
for alias in sub_help.aliases:
if name == alias:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_subcommand(self, name):\n try:\n subcommand_class = self.subcommands[name]\n except KeyError:\n self.print_command_unkown_error(name)\n sys.exit(1)\n return subcommand_class(self.prog, name, self.argv[2:], self.stdout)",
"def HelpForCmd(self, name):... | [
"0.70336854",
"0.70271784",
"0.664786",
"0.6645423",
"0.647728",
"0.6419414",
"0.6092256",
"0.60677403",
"0.6052447",
"0.5968284",
"0.59641016",
"0.5962373",
"0.5933287",
"0.5915913",
"0.59141576",
"0.5910189",
"0.59012985",
"0.5898384",
"0.5896387",
"0.5896387",
"0.5896387",... | 0.78726345 | 0 |
Loads a multilayer png file and return a list of all feature loaded as numpy arrays. You can use np.concatenate(x,2) to create a 3D array of size | def load_png_data():
m=1 #训练文件个数
n=1 #测试文件个数
train_set_x=[]#训练数据集
train_set_y=[]#训练标签集
test_set_x=[]#测试数据集
test_set_y=[]#测试标签集
train_data={}
train_path=r".\dataset\train_label\\"
dirs=os.listdir(train_path)
for file in dirs:
srcImg=cv2.imread(train_path+file)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_image_patch(filename):\n im = Image.open(filename) # .convert('L')\n width, height = im.size\n pixels = list(im.getdata())\n features = [pixels[i * width:(i + 1) * width] for i in range(height)]\n features = np.asarray(im, dtype=np.float32).flatten()\n features /= 255.0\n return feat... | [
"0.71335703",
"0.6792827",
"0.67380095",
"0.67065763",
"0.6583074",
"0.6564765",
"0.6550392",
"0.6415319",
"0.6408479",
"0.639627",
"0.63891566",
"0.63802946",
"0.6377724",
"0.6368443",
"0.6361748",
"0.6327807",
"0.6314867",
"0.6306744",
"0.629919",
"0.62990034",
"0.6297572",... | 0.0 | -1 |
adjust nodes and edges | def add_graphics_theme_to_nx_graph(
nx_graph,
edge_color=None,
node_size_factor=50,
edge_size_factor=500):
# node size, stroke
for node_name, node_attrs in nx_graph.nodes(data=True):
#node_size = nx_graph.nodes[node_name]["numexamples"] / float(node_size_factor)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self):\n\n for node in self.nodes:\n for edge in node.edges:\n for i, edge_node in enumerate(edge.nodes):\n if edge_node.id != node.id:\n edge_node.add_edge(edge)\n\n return self",
"def clean_edges(self):",
"def update... | [
"0.6937063",
"0.69099474",
"0.63684916",
"0.6333464",
"0.6302931",
"0.62989634",
"0.62662923",
"0.62522674",
"0.6176229",
"0.6170671",
"0.6169153",
"0.615478",
"0.61263245",
"0.6126319",
"0.6120976",
"0.6110921",
"0.60948086",
"0.60822624",
"0.6066578",
"0.60385305",
"0.60174... | 0.0 | -1 |
preparatory function for writing out to gml | def stringize_nx_graph(nx_graph):
# graph attributes
for key in nx_graph.graph.keys():
if isinstance(nx_graph.graph[key], (list, set, np.ndarray)):
nx_graph.graph[key] = ",".join([
str(val) for val in list(nx_graph.graph[key])])
# node attributes
for node_name, node_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_graphml_output(self, path):\n self.restructure_edge_info()\n self.restructure_node_info()\n return nx.write_graphml(self.G, path)",
"def write_mm(g, fn):\n f = open(fn, \"w\")\n f.write(\"%d %d %d\\n\" % (g.vcount(), g.vcount(), g.ecount()))\n\n if g.is_weighted():\n for e... | [
"0.6463148",
"0.6297059",
"0.62645066",
"0.6240671",
"0.6203814",
"0.6203347",
"0.61121655",
"0.60968256",
"0.60381806",
"0.6023182",
"0.6010435",
"0.5995649",
"0.5977328",
"0.5961852",
"0.59262574",
"0.5919297",
"0.5915878",
"0.59035015",
"0.58848506",
"0.5878267",
"0.587032... | 0.0 | -1 |
build a network view | def main():
# files
summary_file = sys.argv[1]
pwms_to_tfs_file = sys.argv[2]
expressed_tfs_file = sys.argv[3] # TODO
# TODO pull in num regions to resize things? but complicated with overlaps etc
# TODO edit edges with type of interaction
# TODO may want to color by trajectory, to demonstr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_network(self):\n pass",
"def networks(view):\n return \"network?\" \\\n \"_return_fields=\" \\\n \"extattrs,\" \\\n \"comment,\" \\\n \"network,\" \\\n \"network_view,\" \\\n \"utilization&\" \\\n ... | [
"0.69119674",
"0.65324295",
"0.64664465",
"0.6227124",
"0.61709285",
"0.6079168",
"0.5990852",
"0.59398776",
"0.5891403",
"0.58894837",
"0.587379",
"0.5862538",
"0.5839957",
"0.5753144",
"0.5751551",
"0.567196",
"0.56632817",
"0.5620824",
"0.5600299",
"0.5599422",
"0.55967724... | 0.0 | -1 |
Guard the given spatial reference object against axis swapping, when running with GDAL 3. Does nothing if GDAL < 3. Modifies the object in place. | def preventGdal3axisSwap(sr):
if hasattr(sr, 'SetAxisMappingStrategy'):
sr.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def swap_axis(ogr_geom):\n\n osr_sref = ogr_geom.GetSpatialReference()\n sref = SpatialRef.from_osr(osr_sref)\n if (sref.epsg == 4326) and GDAL_3_ENABLED and (osr_sref.GetAxisMappingStrategy() == 1):\n ogr_geom.SwapXY()\n osr_sref.SetAxisMappingStrategy(0)\n ogr_geom.AssignSpatialRefe... | [
"0.60711205",
"0.57531947",
"0.54899454",
"0.54608077",
"0.5264879",
"0.52497613",
"0.5123439",
"0.51041955",
"0.50515485",
"0.50315267",
"0.5019805",
"0.4985836",
"0.49436423",
"0.4911243",
"0.48981285",
"0.48816335",
"0.4864694",
"0.4860169",
"0.48571274",
"0.48423705",
"0.... | 0.6333744 | 0 |
Given a polygon Geometry object in lat/long, work out what would be a suitable projection to use with this area, in order to avoid things like the international date line wraparound, or the north/sourth pole discontinuities. This only makes sense for tiled products, as opposed to long strips which cross multiple zones,... | def findSensibleProjection(geom):
coords = getCoords(geom)
y = coords[:, 1]
x = coords[:, 0]
yMin = y.min()
yMax = y.max()
if (yMax - yMin) > 90:
# We are crossing a lot of latitude, which suggests that we have a
# long strip> In this case, we don't even bother to suggest an EPS... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def polygon_area(polygon):\n if not PYPROJ_INSTALLED:\n raise ImportError(\"`pyproj` must be installed to use this feature!\")\n poly = wkt_loads(polygon)\n poly_area = shapely.ops.transform(\n partial(\n pyproj.transform,\n pyproj.Proj(init='EPSG:4326'),\n p... | [
"0.6414271",
"0.63134813",
"0.62757397",
"0.60515285",
"0.603324",
"0.59443223",
"0.59352905",
"0.5911644",
"0.58656824",
"0.57909673",
"0.5745204",
"0.57246166",
"0.57246166",
"0.5703267",
"0.5702607",
"0.5696144",
"0.56794995",
"0.5671271",
"0.56611097",
"0.5648878",
"0.561... | 0.693248 | 0 |
Make a pair of ogr.CoordinateTransformation objects, for transforming between the two given EPSG projections. Return a tuple (tr1to2, tr2to1) | def makeTransformations(epsg1, epsg2):
sr1 = osr.SpatialReference()
sr1.ImportFromEPSG(epsg1)
preventGdal3axisSwap(sr1)
sr2 = osr.SpatialReference()
sr2.ImportFromEPSG(epsg2)
preventGdal3axisSwap(sr2)
tr1to2 = osr.CoordinateTransformation(sr1, sr2)
tr2to1 = osr.CoordinateTransformation(s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform_proj(p1, p2, x, y, nocopy=False):\n\n try:\n # This always makes a copy, even if projections are equivalent\n return _transform_internal(p1, p2, x, y, always_xy=True)\n except TypeError:\n if proj_is_same(p1, p2):\n if nocopy:\n return x, y\n ... | [
"0.6856417",
"0.683055",
"0.6792389",
"0.6792389",
"0.67460185",
"0.64127856",
"0.64124286",
"0.63331443",
"0.6282391",
"0.62185615",
"0.6211598",
"0.61743957",
"0.6105238",
"0.60964894",
"0.6039987",
"0.59297293",
"0.591202",
"0.5792901",
"0.5790143",
"0.57694685",
"0.570458... | 0.8401615 | 0 |
Given a geometry as a lat/long polygon, find the lat/long centroid, by first projecting into the preferred EPSG, so as to avoid discontinuities. The preferredEpsg is one in which the polygon ought to make sense (as found, hopefully, by the findSensibleProjection() function). Returns a pair [centroidX, centroidY] in lat... | def findCentroid(geom, preferredEpsg):
(projTr, llTr) = makeTransformations(4326, preferredEpsg)
geomProj = copyGeom(geom)
geomProj.Transform(projTr)
geomCentroid = geomProj.Centroid()
geomCentroid.Transform(llTr)
centroidDict = eval(geomCentroid.ExportToJson())
centroidXY = centro... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_polygon_centroid_2d(polygon):\r\n return geometry.gmComputePolygonCentroid(polygon)",
"def findSensibleProjection(geom):\n coords = getCoords(geom)\n y = coords[:, 1]\n x = coords[:, 0]\n yMin = y.min()\n yMax = y.max()\n if (yMax - yMin) > 90:\n # We are crossing a lot of... | [
"0.6208906",
"0.60699695",
"0.5872511",
"0.5834941",
"0.5801932",
"0.5733032",
"0.56430256",
"0.5637194",
"0.5616599",
"0.5605853",
"0.55601245",
"0.5548161",
"0.55228645",
"0.5449253",
"0.5448886",
"0.5407162",
"0.5400743",
"0.5362452",
"0.526248",
"0.52553886",
"0.5202955",... | 0.7754564 | 0 |
Return a copy of the geometry. OGR does not provide a good method for doing this. | def copyGeom(geom):
geomJson = geom.ExportToJson()
newGeom = ogr.CreateGeometryFromJson(geomJson)
return newGeom | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _prepare_with_copy(geometry):\n geometry = pygeos.apply(geometry, lambda x: x) # makes a copy\n pygeos.prepare(geometry)\n return geometry",
"def getGeometry(self):\n return self.geometry",
"def getGeometry(self):\n return self.geometry",
"def geometry(self):\n return self.... | [
"0.7537405",
"0.73882526",
"0.73882526",
"0.7358205",
"0.7358205",
"0.7251656",
"0.71966004",
"0.71324015",
"0.7120845",
"0.6842374",
"0.6735027",
"0.6728724",
"0.67227095",
"0.6678602",
"0.6662164",
"0.6536648",
"0.65043837",
"0.6306422",
"0.6269604",
"0.6267922",
"0.6248901... | 0.74882305 | 1 |
Return the coordinates of the given OGR geometry. Assumes that this is a single polygon, and returns a numpy array of the x, y coords, of shape (numPts, 2). If the polygon has holes, they will be discarded this is just the outer polygon. If the geometry is a MultiPoint geom, also return a 2d array of coords. | def getCoords(geom):
geomDict = eval(geom.ExportToJson())
coords = geomDict['coordinates']
if geomDict['type'] == 'Polygon':
coordsArray = numpy.array(coords[0])
elif geomDict['type'] == 'MultiPoint':
coordsArray = numpy.array(coords)
else:
coordsArray = None
return coord... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def geomFromInteriorPoints(coords):\n if isinstance(coords, numpy.ndarray):\n coords = coords.tolist()\n geomDict = {'type':'MultiPoint', 'coordinates':coords}\n geomPoints = ogr.CreateGeometryFromJson(repr(geomDict))\n return geomPoints",
"def point_coords(geom):\n # Return a tuple with th... | [
"0.6378374",
"0.6318399",
"0.6230891",
"0.6092643",
"0.598644",
"0.59413916",
"0.5929878",
"0.5911129",
"0.5879037",
"0.5745938",
"0.56728566",
"0.5662459",
"0.5643619",
"0.56382567",
"0.560755",
"0.5599817",
"0.55802184",
"0.5575683",
"0.557035",
"0.55689305",
"0.55629367",
... | 0.72319037 | 0 |
The given list of pairs (or 2d numpy array) is the (x, y) coords of the polygon outline. Return a Polygon ogr.Geometry object. | def geomFromOutlineCoords(coords):
if isinstance(coords, numpy.ndarray):
coords = coords.tolist()
geomDict = {'type':'Polygon', 'coordinates':[coords]}
geom = ogr.CreateGeometryFromJson(repr(geomDict))
return geom | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_polygon(*coords):\n global GEOMETRY_SURF, POLYGONS,col\n if len(coords) < 3:\n print(\"Warning: Invalid polygon passed, ignoring...\")\n return\n start = coords[0]\n prev = coords[0]\n for coord in coords:\n POLYGONS |= {coord}\n line = Boundary(prev[0],prev[1],c... | [
"0.7088763",
"0.6743673",
"0.6743673",
"0.65676457",
"0.65600157",
"0.6526626",
"0.64702845",
"0.64233387",
"0.6330234",
"0.6271293",
"0.6227688",
"0.6217067",
"0.6208036",
"0.6129953",
"0.610706",
"0.6104611",
"0.6093786",
"0.60640717",
"0.6050751",
"0.60261005",
"0.6024823"... | 0.63739526 | 8 |
The given list of pairs (or 2d numpy array) is the (x, y) coords of a set of internal points inside a polygon. Returns a MultiPoint Geometry. | def geomFromInteriorPoints(coords):
if isinstance(coords, numpy.ndarray):
coords = coords.tolist()
geomDict = {'type':'MultiPoint', 'coordinates':coords}
geomPoints = ogr.CreateGeometryFromJson(repr(geomDict))
return geomPoints | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_MultiPolyLists_xy(mpoly):\n # Get the x or y coordinates\n x = []\n y = []\n if isinstance(mpoly,Polygon):\n mpoly = [mpoly]\n for poly in mpoly: # the polygon objects return arrays, it's important they be lists or Bokeh fails\n exterior_coords_x = poly.exterior.coords.xy[0].to... | [
"0.68716544",
"0.65765846",
"0.6421751",
"0.6229348",
"0.6228022",
"0.62237096",
"0.61734176",
"0.6153338",
"0.59607905",
"0.58115107",
"0.58115107",
"0.57220775",
"0.5716397",
"0.5716397",
"0.5684545",
"0.5646158",
"0.56197923",
"0.5619396",
"0.55598253",
"0.55252755",
"0.55... | 0.63562393 | 3 |
Given a MultiPoint geometry object in lat/long, create a polygon of the convex hull of these points. First project the lat/long points into the preferred EPSG, so that when we find the convex hull, we are not crossing any discontinuities such as the international date line. Return a single polygon geometry in lat/long. | def polygonFromInteriorPoints(geom, preferredEpsg):
(projTr, llTr) = makeTransformations(4326, preferredEpsg)
geomProj = copyGeom(geom)
geomProj.Transform(projTr)
geomOutline = geomProj.ConvexHull()
geomOutline.Transform(llTr)
return geomOutline | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convex_hull(self):\n if isinstance(self.crs, GeographicalCRS):\n raise CRSError(\"not implemented for geographical coordinate \"\n \"systems. Project to a projected coordinate system.\")\n\n points = [pt for pt in self]\n\n # Find the lowermost (left?) ... | [
"0.7075242",
"0.6431152",
"0.64101326",
"0.63916564",
"0.63589376",
"0.627315",
"0.61870193",
"0.6043088",
"0.6030819",
"0.59753376",
"0.5926664",
"0.59115064",
"0.5896636",
"0.589403",
"0.5877571",
"0.5867895",
"0.58546466",
"0.5851499",
"0.5834695",
"0.58292884",
"0.5810926... | 0.7046996 | 1 |
Given a Polygon Geometry object, in lat/long, detect whether it crosses the dateline. Do this in the projection of the preferred EPSG, so we remove (reduce?) the ambiguity about inside/outside. | def crossesDateline(geom, preferredEpsg):
(xMin, xMax, yMin, yMax) = geom.GetEnvelope()
(projTr, llTr) = makeTransformations(4326, preferredEpsg)
geomProj = copyGeom(geom)
geomProj.Transform(projTr)
dateLineGeom = ogr.Geometry(wkt='LINESTRING(180 {}, 180 {})'.format(yMin, yMax))
try:
da... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def point_inside_polygon(xxx_todo_changeme,poly):\n (x,y) = xxx_todo_changeme\n n = len(poly)\n inside = False\n\n p1x, p1y = poly[0]\n for i in range(n + 1):\n p2x, p2y = poly[i % n]\n if y > min(p1y, p2y):\n if y <= max(p1y, p2y):\n if x <= max(p1x, p2x):\n ... | [
"0.69540954",
"0.6897939",
"0.6799872",
"0.6788985",
"0.67285305",
"0.66589004",
"0.6657012",
"0.6512406",
"0.64687806",
"0.64495367",
"0.64015037",
"0.63911974",
"0.6390966",
"0.6381956",
"0.6351574",
"0.62924826",
"0.62201375",
"0.61754906",
"0.611618",
"0.6106009",
"0.6104... | 0.7383287 | 0 |
Given a Polygon Geometry object in lat/long, determine whether it crosses the date line, and if so, split it into a multipolygon with a part on either side. Use the given preferred EPSG to perform calculations. Return a new Geometry in lat/long. | def splitAtDateline(geom, preferredEpsg):
crosses = crossesDateline(geom, preferredEpsg)
if crosses:
(projTr, llTr) = makeTransformations(4326, preferredEpsg)
coords = getCoords(geom)
(x, y) = (coords[:, 0], coords[:, 1])
(yMin, yMax) = (y.min(), y.max())
xMinPositive = N... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crossesDateline(geom, preferredEpsg):\n (xMin, xMax, yMin, yMax) = geom.GetEnvelope()\n (projTr, llTr) = makeTransformations(4326, preferredEpsg)\n\n geomProj = copyGeom(geom)\n geomProj.Transform(projTr)\n dateLineGeom = ogr.Geometry(wkt='LINESTRING(180 {}, 180 {})'.format(yMin, yMax))\n try... | [
"0.67136943",
"0.63109124",
"0.5897794",
"0.56662834",
"0.5617019",
"0.5594572",
"0.5547453",
"0.55368793",
"0.5471673",
"0.5448653",
"0.54439175",
"0.54206467",
"0.5395042",
"0.53801703",
"0.5376376",
"0.5372196",
"0.5371982",
"0.5348414",
"0.53426564",
"0.53149515",
"0.5310... | 0.76047856 | 0 |
Test that invalid tokens works | def test_invalid_tokens(self):
self.assertTrue(1 + 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_unused_token_is_valid(self):\n assert self.token.is_valid()",
"def test_regex_invalid_tokens(self):\n tokens = (\n \"\",\n \"lemon wins\",\n \"..\",\n \"x.y\",\n \"x.y.\",\n \".y.z\",\n \".y.\",\n \"..z... | [
"0.8261625",
"0.7524087",
"0.74162",
"0.72980505",
"0.7251938",
"0.7226254",
"0.714365",
"0.71125466",
"0.70883507",
"0.70597327",
"0.7019325",
"0.7010936",
"0.7009519",
"0.6961416",
"0.6934247",
"0.68621945",
"0.6833543",
"0.6818326",
"0.68157536",
"0.6811885",
"0.6800639",
... | 0.87907505 | 0 |
This function prints and plots the confusion matrix. Normalization can be applied by setting `normalize=True`. | def plot_confusion_matrix(cm, classes,
normalize=False,
title=None,
cmap=plt.cm.Blues,
image_save=False,
image_save_dir="/home/temp/moriz/validation/",
save_suffix=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_confusion_matrix(cm, classes=[0,1], normalize=False, title='Confusion matrix', print_matrix=False):\n\n if normalize:\n cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n print(\"Normalized confusion matrix\")\n else:\n print('Confusion matrix, without normalization')\n\n... | [
"0.8194862",
"0.80949175",
"0.8029915",
"0.8019153",
"0.79941195",
"0.7991258",
"0.7980955",
"0.7976606",
"0.79610753",
"0.79590565",
"0.79378676",
"0.7934962",
"0.7934504",
"0.79313844",
"0.7926313",
"0.7924577",
"0.79241234",
"0.7923211",
"0.7923023",
"0.7921931",
"0.791787... | 0.0 | -1 |
Proxy to turn of transcypt when calling img.get/set methods | def image_proxy(img):
def _set(*args):
__pragma__("noalias", "set")
value = img.set(*args)
__pragma__("alias", "set", "py_set")
return value
def _get(*args):
__pragma__("noalias", "get")
value = img.get(*args)
__pragma__("alias", "get", "py_get")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, img, *args, **kwargs):\n raise NotImplementedError",
"def __call__(self, img, *args, **kwargs):\n raise NotImplementedError",
"def __init__(self, img, settings):\r\n self.img_orig = img\r\n self.settings = settings",
"def _apply_transform(self, img: np.ndarray):... | [
"0.6246118",
"0.6246118",
"0.62181085",
"0.6194361",
"0.6194361",
"0.60827804",
"0.606501",
"0.6059099",
"0.59579223",
"0.59201604",
"0.5910337",
"0.58504593",
"0.5800288",
"0.5793381",
"0.5784016",
"0.5776674",
"0.5700956",
"0.56607634",
"0.5656199",
"0.56306195",
"0.5605271... | 0.7732635 | 0 |
We need to run this before the actual draw to insert and update p5 env variables | def pre_draw(p5_instance, draw_func):
global _CTX_MIDDLE, _DEFAULT_FILL, _DEFAULT_LEADMULT, _DEFAULT_STROKE, _DEFAULT_TEXT_FILL
global ADD, ALT, ARROW, AUTO, AUDIO, AXES, BACKSPACE, BASELINE, BEVEL, BEZIER, BLEND, BLUR, BOLD, BOLDITALIC
global BOTTOM, BURN, CENTER, CHORD, CLAMP, CLOSE, CONTROL, CORNER, COR... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_draw(self):\n pass",
"def pointsSetUp(self):\r\n self.background.draw(self.surface)\r\n for i in range(len(self.points)):\r\n self.points[i].organize()\r\n self.points[i].update()\r\n self.points[i].addNumber(i)\r\n self.points[i].setActi... | [
"0.6523757",
"0.6017574",
"0.5880544",
"0.5814766",
"0.57777816",
"0.5713455",
"0.5674024",
"0.56632835",
"0.56570673",
"0.5616937",
"0.56138486",
"0.5583289",
"0.5570645",
"0.55119085",
"0.5494234",
"0.546833",
"0.54369044",
"0.54284686",
"0.54177946",
"0.5411796",
"0.540187... | 0.6062119 | 1 |
Injects the p5js's skecth instance as a global variable to setup and draw functions | def global_p5_injection(p5_sketch):
def decorator(f):
def wrapper():
global _P5_INSTANCE
_P5_INSTANCE = p5_sketch
return pre_draw(_P5_INSTANCE, f)
return wrapper
return decorator | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup():\r\n #this happens just once\r\n size(width, height) #instead of create_canvas\r",
"def __init__(self, parent):\n super(P5, self).__init__(parent)\n self.shapes = []\n self.scenes = []\n self.current_scene = 0\n self.objects = []\n self.lighting = True\... | [
"0.6492295",
"0.6341241",
"0.6277463",
"0.6121529",
"0.5968284",
"0.5964794",
"0.5882622",
"0.5853329",
"0.5788281",
"0.5773192",
"0.5767879",
"0.5749697",
"0.5735698",
"0.5676923",
"0.56400704",
"0.5595668",
"0.55945295",
"0.558435",
"0.5566732",
"0.55556136",
"0.55504155",
... | 0.63667154 | 1 |
Calculates the local density of states of a hamiltonian and writes it in file | def ldos0d(h,e=0.0,delta=0.01):
if h.dimensionality==0: # only for 0d
iden = np.identity(h.intra.shape[0],dtype=np.complex) # create identity
g = ( (e+1j*delta)*iden -h.intra ).I # calculate green function
else: raise # not implemented...
d = [ -(g[i,i]).imag/np.pi for i in range(len(g))] # get imaginary... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_density(fname, density):\n K, M, N = density.shape\n output = open(fname, \"w\")\n output.write(\"ARMA_CUB_TXT_FN008\\n\")\n output.write(\"%d %d %d\\n\" % (K, M, N))\n for i in range(N):\n for k in range(K):\n for m in range(M):\n output.write(\" %+.6e\" ... | [
"0.55582106",
"0.54553246",
"0.5443375",
"0.5435445",
"0.53110385",
"0.5228803",
"0.51917344",
"0.5187912",
"0.51358545",
"0.5119606",
"0.5118766",
"0.5114473",
"0.5104518",
"0.5102728",
"0.5058224",
"0.5031976",
"0.50309247",
"0.5023144",
"0.5012087",
"0.50105166",
"0.500671... | 0.0 | -1 |
Calculates the local density of states of a hamiltonian and writes it in file, using arpack | def ldos0d_wf(h,e=0.0,delta=0.01,num_wf = 10,robust=False,tol=0):
if h.dimensionality==0: # only for 0d
intra = csc_matrix(h.intra) # matrix
else: raise # not implemented...
if robust: # go to the imaginary axis for stability
eig,eigvec = slg.eigs(intra,k=int(num_wf),which="LM",
s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_density(fname, density):\n K, M, N = density.shape\n output = open(fname, \"w\")\n output.write(\"ARMA_CUB_TXT_FN008\\n\")\n output.write(\"%d %d %d\\n\" % (K, M, N))\n for i in range(N):\n for k in range(K):\n for m in range(M):\n output.write(\" %+.6e\" ... | [
"0.56314754",
"0.55677277",
"0.55518115",
"0.53848726",
"0.5382426",
"0.53711474",
"0.5332129",
"0.53105676",
"0.52964735",
"0.52770823",
"0.5270333",
"0.52593464",
"0.524486",
"0.52432036",
"0.5242412",
"0.5241068",
"0.5220861",
"0.52199006",
"0.5214131",
"0.52032506",
"0.51... | 0.0 | -1 |
Use arpack to calculate hte local density of states at a certain energy | def ldos_arpack(intra,num_wf=10,robust=False,tol=0,e=0.0,delta=0.01):
if robust: # go to the imaginary axis for stability
eig,eigvec = slg.eigs(intra,k=int(num_wf),which="LM",
sigma=e+1j*delta,tol=tol)
eig = eig.real # real part only
else: # Hermitic Hamiltonian
eig,eigvec = slg... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_density(\n self,\n states: FlowFieldMap,\n additional_states: FlowFieldMap,\n ) -> FlowFieldVal:\n zz = additional_states.get('zz', [tf.constant(0, dtype=TF_DTYPE)] *\n self._params.nz)\n\n if 'T' in states:\n t = states['T']\n elif 'theta' in ... | [
"0.639904",
"0.6349566",
"0.6122259",
"0.587715",
"0.5850544",
"0.5828956",
"0.5805845",
"0.57823133",
"0.57640857",
"0.5762716",
"0.575468",
"0.5743525",
"0.57068014",
"0.568855",
"0.56624216",
"0.56600386",
"0.5653631",
"0.56313336",
"0.5620443",
"0.56074494",
"0.56047225",... | 0.0 | -1 |
Calculate the DOS in a set of energies by full diagonalization | def ldos_waves(intra,es = [0.0],delta=0.01):
es = np.array(es) # array with energies
eig,eigvec = lg.eigh(intra)
ds = [] # empty list
for energy in es: # loop over energies
d = np.array([0.0 for i in range(intra.shape[0])]) # initialize
for (v,ie) in zip(eigvec.transpose(),eig): # loop over wavefunctio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dos_integral(E,dos,m=0):\n somma = 0.0\n h = 0.5*(E[2]-E[0])\n for j in range(0,len(dos)-3,3):\n somma += 3.0*pow(E[j],m)*dos[j]+3.0*pow(E[j+1],m)*dos[j+1]+2.0*pow(E[j+2],m)*dos[j+2]\n \n return h*somma*3.0/8.0;",
"def multi_ldos(h,es=[0.0],delta=0.001,nrep=3,nk=2,numw=3,random=Fals... | [
"0.61792886",
"0.59270054",
"0.586323",
"0.57872564",
"0.57571954",
"0.57146597",
"0.5687018",
"0.5637377",
"0.56015885",
"0.55990046",
"0.5590492",
"0.5574188",
"0.55615056",
"0.55407554",
"0.5533155",
"0.5531143",
"0.5525705",
"0.5469803",
"0.545624",
"0.5441904",
"0.543674... | 0.51186496 | 77 |
Write a map of the ldos using full diagonalization | def ldosmap(h,energies=np.linspace(-1.0,1.0,40),delta=None,nk=40):
if delta is None:
delta = (np.max(energies)-np.min(energies))/len(energies) # delta
hkgen = h.get_hk_gen() # get generator
dstot = np.zeros((len(energies),h.intra.shape[0])) # initialize
for ik in range(nk):
print("Random k-point",ik,nk... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slabldos(h,energies=np.linspace(-1.0,1.0,40),delta=None,nk=40):\n if h.dimensionality!=2: raise # nope\n ds = ldosmap(h,energies=energies,delta=delta,nk=nk)\n if len(ds[0])!=len(h.geometry.z): \n print(\"Wrong dimensions\",len(ds[0]),len(h.geometry.z))\n raise\n f = open(\"DOSMAP.OUT\",\"w\")\n f.wr... | [
"0.655839",
"0.6347875",
"0.59854907",
"0.5929425",
"0.58443075",
"0.5822576",
"0.5790556",
"0.577992",
"0.57649004",
"0.5739247",
"0.5735068",
"0.5722867",
"0.5628976",
"0.5559443",
"0.5539078",
"0.55376244",
"0.55363584",
"0.55267847",
"0.5493117",
"0.5472624",
"0.5431082",... | 0.60297304 | 2 |
Computes the DOS for each site of an slab, only for 2d | def slabldos(h,energies=np.linspace(-1.0,1.0,40),delta=None,nk=40):
if h.dimensionality!=2: raise # nope
ds = ldosmap(h,energies=energies,delta=delta,nk=nk)
if len(ds[0])!=len(h.geometry.z):
print("Wrong dimensions",len(ds[0]),len(h.geometry.z))
raise
f = open("DOSMAP.OUT","w")
f.write("# energy, ind... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_msd(pos_x, pos_y, pos_z):\n particles = pos_x.shape[0]\n N = pos_x.shape[1] \n tamsd = np.zeros(shape = (particles, N - 1)) \n\n for p in np.arange(start = 0, stop = particles, step = 1): \n for n in np.arange(start = 1, stop = N, step = 1): \n sumdis = np.array([((pos_x[p, i... | [
"0.5823131",
"0.56665945",
"0.5654268",
"0.56067395",
"0.5549059",
"0.5487201",
"0.5425105",
"0.53680533",
"0.5335588",
"0.5313948",
"0.53035074",
"0.52599955",
"0.52019894",
"0.51405936",
"0.5140454",
"0.51258785",
"0.5124321",
"0.5116561",
"0.5109169",
"0.5090838",
"0.50795... | 0.63072735 | 0 |
Calculate DOS for a 1d system | def ldos1d(h,e=0.0,delta=0.001,nrep=3):
import green
if h.dimensionality!=1: raise # only for 1d
gb,gs = green.green_renormalization(h.intra,h.inter,energy=e,delta=delta)
d = [ -(gb[i,i]).imag for i in range(len(gb))] # get imaginary part
d = spatial_dos(h,d) # convert to spatial resolved DOS
g = h.geometry... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dsurface_domega(self):\n\n dsdo = 0.\n\n return dsdo",
"def get_dos(self):\n\n return self.get_array('dos')",
"def dVdx(self, sys):\n dx2 = sys.positions * sys.positions - self.x0 * self.x0\n return 4 * self.A * sys.positions * dx2",
"def dVdx(self, sys):\n dx =... | [
"0.57057214",
"0.55718416",
"0.54609364",
"0.5383514",
"0.5373876",
"0.52895164",
"0.52246433",
"0.5127203",
"0.5026564",
"0.5012178",
"0.5005394",
"0.49850887",
"0.49414775",
"0.49326056",
"0.49182996",
"0.4915729",
"0.49154025",
"0.4866256",
"0.48534217",
"0.48473454",
"0.4... | 0.0 | -1 |
Calculate DOS for a 2d system | def ldos2d(h,e=0.0,delta=0.001,nrep=3,nk=None,mode="green",
random=True,num_wf=20):
if mode=="green":
import green
if h.dimensionality!=2: raise # only for 1d
if nk is not None:
print("LDOS using normal integration with nkpoints",nk)
gb,gs = green.bloch_selfenergy(h,energy=e,delta... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dVdx(self, sys):\n dx2 = sys.positions * sys.positions - self.x0 * self.x0\n return 4 * self.A * sys.positions * dx2",
"def _dsurface_domega(self):\n\n dsdo = 0.\n\n return dsdo",
"def dVdx(self, sys):\n dx = sys.positions - self.x0\n k = self.omega*self.omega*sys.... | [
"0.6104026",
"0.5681574",
"0.5631583",
"0.545737",
"0.53376925",
"0.5288433",
"0.52243865",
"0.5200089",
"0.5097595",
"0.5092457",
"0.50678277",
"0.50439966",
"0.5032084",
"0.5018616",
"0.50028914",
"0.50016",
"0.4991276",
"0.49865207",
"0.49861157",
"0.49838954",
"0.4969009"... | 0.0 | -1 |
Calculate many LDOS, by diagonalizing the Hamiltonian | def multi_ldos(h,es=[0.0],delta=0.001,nrep=3,nk=2,numw=3,random=False):
print("Calculating eigenvectors in LDOS")
if h.is_sparse: # sparse Hamiltonian
from bandstructure import smalleig
print("SPARSE Matrix")
evals,ws = [],[] # empty list
ks = klist.kmesh(h.dimensionality,nk=nk) # get grid
hk = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def diagonals_in_hd():\n number_of_pairs = 100000\n angles_for_d = {}\n for d in (10, 100, 1000):\n number_of_corners = 2 ** d - 1\n first_corner = [random.randint(0, number_of_corners) for _ in range(0, number_of_pairs)]\n second_corner = [random.randint(0, number_of_corners) for _ i... | [
"0.6510543",
"0.6441997",
"0.616607",
"0.6134413",
"0.607191",
"0.59936696",
"0.59168214",
"0.58911335",
"0.5871839",
"0.58278966",
"0.5818667",
"0.58146787",
"0.5806394",
"0.5788211",
"0.57797736",
"0.57464814",
"0.57270575",
"0.5663071",
"0.56431705",
"0.56420153",
"0.56268... | 0.68332195 | 0 |
Resums a certain DOS to show only the spatial dependence | def spatial_dos(h,dos):
if h.has_spin == False and h.has_eh==False: return np.array(dos)
elif h.has_spin == True and h.has_eh==False:
return np.array([dos[2*i]+dos[2*i+1] for i in range(len(dos)//2)])
elif h.has_spin == False and h.has_eh==True:
return np.array([dos[2*i]+dos[2*i+1] for i in range(len(do... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def grass_drass():",
"def system_fleet_dimensioning(self):",
"def display_ds9(ds9_name, image_id):\n os.system('xpaset {} fits < {}'.format(ds9_name, image_id))",
"def execute(self, parameters, messages):\n\n\n\n arcpy.AddMessage(\"default.gdb_path: %s\" % arcpy.env.workspace)\n\n\n arcpy.Im... | [
"0.53796166",
"0.5276114",
"0.5230221",
"0.5218842",
"0.5199459",
"0.5192862",
"0.519138",
"0.5182484",
"0.5131913",
"0.5114713",
"0.51103306",
"0.5051443",
"0.50511736",
"0.5021749",
"0.4996543",
"0.49938875",
"0.498227",
"0.49754798",
"0.49719897",
"0.49481302",
"0.49481302... | 0.0 | -1 |
Write LDOS in a file | def write_ldos(x,y,dos,output_file="LDOS.OUT",z=None):
fd = open(output_file,"w") # open file
fd.write("# x, y, local density of states\n")
ii = 0
for (ix,iy,idos) in zip(x,y,dos): # write everything
fd.write(str(ix) +" "+ str(iy) + " "+ str(idos))
if z is not None: fd.write(" "+str(z[ii]))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_file(l_dta, outputfile):\n l_dta2 = []\n for row in l_dta:\n s = '\\t'.join(row)\n l_dta2.append(s)\n s_dta = \"\\r\\n\".join(l_dta2)\n try:\n with open(outputfile, 'w') as fd:\n fd.write(s_dta)\n except (IOError,) as e:\n tracker()\n return None",... | [
"0.63052565",
"0.5946495",
"0.5859641",
"0.58320624",
"0.58302605",
"0.57833433",
"0.5733278",
"0.5729144",
"0.5711805",
"0.56135124",
"0.5603127",
"0.55708736",
"0.55650675",
"0.55446815",
"0.5522803",
"0.552071",
"0.55121875",
"0.5507822",
"0.5500877",
"0.5473531",
"0.54703... | 0.6843431 | 0 |
Calculate the density of states for a finite system | def ldos_finite(h,e=0.0,n=10,nwf=4,delta=0.0001):
if h.dimensionality!=1: raise # if it is not one dimensional
intra = csc(h.intra) # convert to sparse
inter = csc(h.inter) # convert to sparse
interH = inter.H # hermitian
m = [[None for i in range(n)] for j in range(n)] # full matrix
for i in range(n): # ad... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getDensityOfStates(self, Elist):\n\t\treturn _modes.freerotor_densityofstates(Elist, self.frequencies, 1 if self.linear else 0)",
"def getDensityOfStates(self, Elist):\n\t\trho = np.zeros((len(Elist)), np.float64)\n\t\trho0 = _modes.hinderedrotor_densityofstates(Elist, self.frequency, self.barrier)\n\t\tfor ... | [
"0.6842676",
"0.6838163",
"0.66934264",
"0.66780734",
"0.6619658",
"0.6589051",
"0.6474599",
"0.63931894",
"0.63873273",
"0.63801605",
"0.6272464",
"0.62401986",
"0.6229511",
"0.61976075",
"0.6176228",
"0.6112314",
"0.6104218",
"0.60965395",
"0.60946393",
"0.60946393",
"0.609... | 0.0 | -1 |
Calculates the LDOS of a cell with a defect, writting the n neighring cells | def ldos_defect(h,v,e=0.0,delta=0.001,n=1):
raise # still not finished
import green
# number of repetitions
rep = 2*n +1
# calculate pristine green function
g,selfe = green.supercell_selfenergy(h,e=e,delta=delta,nk=100,nsuper=rep)
# now calculate defected green function
ez = e + 1j*delta # complex ener... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slabldos(h,energies=np.linspace(-1.0,1.0,40),delta=None,nk=40):\n if h.dimensionality!=2: raise # nope\n ds = ldosmap(h,energies=energies,delta=delta,nk=nk)\n if len(ds[0])!=len(h.geometry.z): \n print(\"Wrong dimensions\",len(ds[0]),len(h.geometry.z))\n raise\n f = open(\"DOSMAP.OUT\",\"w\")\n f.wr... | [
"0.6147432",
"0.5673565",
"0.5628075",
"0.5538174",
"0.5529582",
"0.54913837",
"0.54828596",
"0.5471573",
"0.54613155",
"0.5456147",
"0.5440528",
"0.5422581",
"0.54167837",
"0.5389832",
"0.5379038",
"0.53487825",
"0.53432304",
"0.53047895",
"0.53021795",
"0.52806985",
"0.5250... | 0.572953 | 1 |
Calculate next best sample location | def acquisition(self):
fs, _ = self.gp.predict(self.gp.X)
next_fs, vars = self.gp.predict(self.X_s)
opt = np.min(fs)
improves = opt - next_fs - self.xsi
Z = improves / vars
eis = improves * norm.cdf(Z) + vars * norm.pdf(Z)
return self.X_s[np.argmax(eis)], e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_next_sample(self):",
"def decide_next_query(self):\n for gp in self.gps:\n build_gp_posterior(gp)\n # Find the best mean values for each gp.\n best_f, best_pt, best_gain = None, None, float('-inf')\n queries = self._get_queried_pts()\n for f_idx, f_name in en... | [
"0.71639574",
"0.6434643",
"0.6302643",
"0.6135785",
"0.6110737",
"0.60888207",
"0.601396",
"0.60047734",
"0.5961023",
"0.59551257",
"0.5950009",
"0.59325665",
"0.59085697",
"0.58706766",
"0.58677566",
"0.58429563",
"0.58406365",
"0.58211887",
"0.58168864",
"0.5816688",
"0.57... | 0.0 | -1 |
Optimize for black box function | def optimize(self, iterations=1000):
prev = None
finalx = None
finaly = None
while iterations:
maxei, eis = self.acquisition()
new_y = self.f(maxei)
if maxei == prev:
break
self.gp.update(maxei, new_y)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def blackwin(x):\n print('blackwin is untested')\n if isinstance(x, (list, tuple, np.ndarray)):\n n = x.shape[1]\n f = blackwin(n)\n\n if len(x.shape) == 3:\n f, _, _ = np.meshgrid(f[0, :], np.arange(\n x.shape[0]), np.arange(x.shape[2]))\n else:\n ... | [
"0.60105205",
"0.5797661",
"0.57564193",
"0.57291317",
"0.56770235",
"0.56659347",
"0.5652914",
"0.5614355",
"0.56009203",
"0.5584697",
"0.5571387",
"0.5517217",
"0.5487182",
"0.5478953",
"0.54679054",
"0.5436867",
"0.54337466",
"0.53844154",
"0.53843486",
"0.5379643",
"0.536... | 0.0 | -1 |
Delete the created network when site creation failed | def _delete_vpn(self, request, vpn):
try:
#api.quantum.network_delete(request, network.id)
msg = _('Delete the created VPN "%s" '
'due to site addition failure.') % vpn_name
LOG.debug(msg)
redirect = self.get_failure_url()
messages.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_network(self):\n pass",
"def delete_networks(self):\n logging.debug(\"cleanup called\")\n # for network in self.networks.key():\n # self.networks[network].delete()\n for network in self.networks.values():\n logging.warn(\"Deleting network '%s'\" %... | [
"0.67859447",
"0.6550001",
"0.65075684",
"0.64984155",
"0.646287",
"0.6276366",
"0.61979026",
"0.6197258",
"0.61300117",
"0.6093675",
"0.6090884",
"0.5948053",
"0.5943114",
"0.5920346",
"0.5890928",
"0.58596253",
"0.5844363",
"0.5840034",
"0.58133364",
"0.5790481",
"0.5786879... | 0.53581345 | 51 |
Take JSON as string returned from a Playfield API request and parse data section into list of dicts {field_name=data} | def parse_json(self, json_to_parse):
json_obj = json.loads(json_to_parse)
return_data = []
for row in json_obj['data']:
row_dict = {}
for key, value in row.items():
row_dict[key] = value
return_data.append(row_dict)
return return_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dig_fields(json_data):\n data = json.loads(json_data)\n fields = [f for f in data]\n return fields",
"def parse(data, datetime_field=None):\n\n parsed_data = json.loads(data)\n if datetime_field:\n if isinstance(parsed_data, list):\n for item in parsed_data:\n ... | [
"0.68718296",
"0.66720295",
"0.6531521",
"0.6174297",
"0.6158747",
"0.6148615",
"0.60345334",
"0.60218924",
"0.5973685",
"0.5921073",
"0.5912757",
"0.5910022",
"0.58769304",
"0.58715916",
"0.5844883",
"0.58414644",
"0.5825254",
"0.5811341",
"0.57988477",
"0.57882863",
"0.5775... | 0.60061646 | 8 |
Constructor parent reference to the parent widget QWidget | def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self, parent):\n self.widget = QtCore.QObject(parent)",
"def __init__(self, parent=None):\n super(Dialog, self).__init__(parent)\n self.setupUi(self)",
"def __init__(self, parent=None):\n super(Form, self).__init__(parent)\n self.setupUi(self)",
"def __init__(sel... | [
"0.80446535",
"0.790637",
"0.7829028",
"0.7829028",
"0.7818371",
"0.76782995",
"0.76558757",
"0.76455885",
"0.7594716",
"0.7536031",
"0.75227404",
"0.751839",
"0.7513868",
"0.7468696",
"0.74049985",
"0.7376986",
"0.736306",
"0.73554814",
"0.7326882",
"0.7282546",
"0.7282546",... | 0.770407 | 8 |
Slot documentation goes here. | def on_pushButton_clicked(self):
# TODO: not implemented yet
print("加载数据")
boston = datasets.load_boston()
train = boston.data
target = boston.target
self.X_train,self.x_test,self.y_train,self.y_true = train_test_split(train,target,test_size=0.2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slot(self, name):\n raise ClixxException(\"Not implemented.\")",
"def play_slot__(self):\n print(\"play_slot__\")\n self.valkkafs_manager.play()",
"def add_slot(self, slot):\n slot.set_location(len(self.slots)+1)\n self.slots.append(slot)",
"def visit_slot(self, slot_name: str, slo... | [
"0.7317067",
"0.6809478",
"0.6723371",
"0.6583449",
"0.63984954",
"0.63675296",
"0.63494873",
"0.6319528",
"0.63195074",
"0.631188",
"0.6152515",
"0.6127954",
"0.61003345",
"0.6093386",
"0.60838413",
"0.6083497",
"0.6056153",
"0.60259384",
"0.6022296",
"0.6002864",
"0.5981298... | 0.0 | -1 |
Slot documentation goes here. | def on_pushButton_2_clicked(self):
# TODO: not implemented yet
print("模型预测")
# 模型加载
lr_m = joblib.load("model/LR_model.m")
rr_m = joblib.load("model/RR_model.m")
llr_m = joblib.load("model/LLR_model.m")
knnr_m = joblib.load("model/KNNR_model.m")
d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slot(self, name):\n raise ClixxException(\"Not implemented.\")",
"def play_slot__(self):\n print(\"play_slot__\")\n self.valkkafs_manager.play()",
"def add_slot(self, slot):\n slot.set_location(len(self.slots)+1)\n self.slots.append(slot)",
"def visit_slot(self, slot_name: str, slo... | [
"0.73193145",
"0.6811926",
"0.6725808",
"0.65843606",
"0.6397118",
"0.6368233",
"0.63534164",
"0.63223046",
"0.6321543",
"0.6312873",
"0.6151129",
"0.6127017",
"0.6102243",
"0.60954756",
"0.60865855",
"0.6085341",
"0.60555625",
"0.6027709",
"0.6023868",
"0.60039294",
"0.59816... | 0.0 | -1 |
Slot documentation goes here. | def on_action_triggered(self):
# TODO: not implemented yet
print('打开')
my_button_open = QMessageBox.about(self, '打开', '点击我打开某些文件') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slot(self, name):\n raise ClixxException(\"Not implemented.\")",
"def play_slot__(self):\n print(\"play_slot__\")\n self.valkkafs_manager.play()",
"def add_slot(self, slot):\n slot.set_location(len(self.slots)+1)\n self.slots.append(slot)",
"def visit_slot(self, slot_name: str, slo... | [
"0.73193145",
"0.6811926",
"0.6725808",
"0.65843606",
"0.6397118",
"0.6368233",
"0.63534164",
"0.63223046",
"0.6321543",
"0.6312873",
"0.6151129",
"0.6127017",
"0.6102243",
"0.60954756",
"0.60865855",
"0.6085341",
"0.60555625",
"0.6027709",
"0.6023868",
"0.60039294",
"0.59816... | 0.0 | -1 |
Slot documentation goes here. | def on_action_2_triggered(self):
# TODO: not implemented yet
print('关闭')
sys.exit(0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slot(self, name):\n raise ClixxException(\"Not implemented.\")",
"def play_slot__(self):\n print(\"play_slot__\")\n self.valkkafs_manager.play()",
"def add_slot(self, slot):\n slot.set_location(len(self.slots)+1)\n self.slots.append(slot)",
"def visit_slot(self, slot_name: str, slo... | [
"0.73193145",
"0.6811926",
"0.6725808",
"0.65843606",
"0.6397118",
"0.6368233",
"0.63534164",
"0.63223046",
"0.6321543",
"0.6312873",
"0.6151129",
"0.6127017",
"0.6102243",
"0.60954756",
"0.60865855",
"0.6085341",
"0.60555625",
"0.6027709",
"0.6023868",
"0.60039294",
"0.59816... | 0.0 | -1 |
Slot documentation goes here. | def on_action_3_triggered(self):
# TODO: not implemented yet
print('联系我们')
my_button_con_me = QMessageBox.about(self, '联系我们', '这个位置放的是联系我们的介绍') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slot(self, name):\n raise ClixxException(\"Not implemented.\")",
"def play_slot__(self):\n print(\"play_slot__\")\n self.valkkafs_manager.play()",
"def add_slot(self, slot):\n slot.set_location(len(self.slots)+1)\n self.slots.append(slot)",
"def visit_slot(self, slot_name: str, slo... | [
"0.7317067",
"0.6809478",
"0.6723371",
"0.6583449",
"0.63984954",
"0.63675296",
"0.63494873",
"0.6319528",
"0.63195074",
"0.631188",
"0.6152515",
"0.6127954",
"0.61003345",
"0.6093386",
"0.60838413",
"0.6083497",
"0.6056153",
"0.60259384",
"0.6022296",
"0.6002864",
"0.5981298... | 0.0 | -1 |
Slot documentation goes here. | def on_action_4_triggered(self):
# TODO: not implemented yet
print('关于我们')
my_button_about_me = QMessageBox.about(self, '关于我们', '这个位置放的是关于我们的介绍') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slot(self, name):\n raise ClixxException(\"Not implemented.\")",
"def play_slot__(self):\n print(\"play_slot__\")\n self.valkkafs_manager.play()",
"def add_slot(self, slot):\n slot.set_location(len(self.slots)+1)\n self.slots.append(slot)",
"def visit_slot(self, slot_name: str, slo... | [
"0.73193145",
"0.6811926",
"0.6725808",
"0.65843606",
"0.6397118",
"0.6368233",
"0.63534164",
"0.63223046",
"0.6321543",
"0.6312873",
"0.6151129",
"0.6127017",
"0.6102243",
"0.60954756",
"0.60865855",
"0.6085341",
"0.60555625",
"0.6027709",
"0.6023868",
"0.60039294",
"0.59816... | 0.0 | -1 |
Slot documentation goes here. | def on_action_QT_triggered(self):
# TODO: not implemented yet
print('关于qt')
my_button_about_QT = QMessageBox.aboutQt(self, '关于QT') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slot(self, name):\n raise ClixxException(\"Not implemented.\")",
"def play_slot__(self):\n print(\"play_slot__\")\n self.valkkafs_manager.play()",
"def add_slot(self, slot):\n slot.set_location(len(self.slots)+1)\n self.slots.append(slot)",
"def visit_slot(self, slot_name: str, slo... | [
"0.73193145",
"0.6811926",
"0.6725808",
"0.65843606",
"0.6397118",
"0.6368233",
"0.63534164",
"0.63223046",
"0.6321543",
"0.6312873",
"0.6151129",
"0.6127017",
"0.6102243",
"0.60954756",
"0.60865855",
"0.6085341",
"0.60555625",
"0.6027709",
"0.6023868",
"0.60039294",
"0.59816... | 0.0 | -1 |
Create a new Band. Created band is a python representation of the Band.Create case class in the scala datamodel | def __init__(self, name, number, wavelength):
self.name = name
self.number = number
self.wavelength = wavelength | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_bands(band_number):\n try:\n band_dict = band_lookup[band_number]\n except KeyError:\n raise KeyError('Band %s does not exist', band_number)\n\n return [Band(**band_dict)]",
"def __init__(self, lbda=None, bandname=None, zp=None, \n mjd=None, empty=False,**kwa... | [
"0.6518197",
"0.64347064",
"0.5994854",
"0.5890965",
"0.57064843",
"0.57064843",
"0.5659268",
"0.56355095",
"0.5517736",
"0.54783046",
"0.5404359",
"0.5397878",
"0.5396625",
"0.53284055",
"0.5327761",
"0.5327761",
"0.53230125",
"0.5319953",
"0.52875245",
"0.5253581",
"0.52532... | 0.0 | -1 |
Associates the specified blobs with the given encryption keys. | def WriteBlobEncryptionKeys(
self,
key_names: Dict[rdf_objects.BlobID, str],
) -> None:
self.blob_keys.update(key_names) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def volume_encryption_keys(self, volume_encryption_keys):\n\n self._volume_encryption_keys = volume_encryption_keys",
"def test_blob_key_stored():\n\tbackup_and_restore(\n\t\tlambda context: put_keys(lib.SET, BLOB_KEYS, \"foobar\", True),\n\t\tNone,\n\t\tlambda context: check_keys(lib.SET, BLOB_KEYS, \"fo... | [
"0.5732032",
"0.55105233",
"0.54380447",
"0.5313522",
"0.5286251",
"0.5265419",
"0.5222959",
"0.52177703",
"0.5150052",
"0.51047397",
"0.5063412",
"0.50368476",
"0.49367145",
"0.49267337",
"0.49244836",
"0.4919951",
"0.49074957",
"0.49044165",
"0.49000615",
"0.4885995",
"0.48... | 0.7061965 | 0 |
Retrieves encryption keys associated with blobs. | def ReadBlobEncryptionKeys(
self,
blob_ids: Collection[rdf_objects.BlobID],
) -> Dict[rdf_objects.BlobID, Optional[str]]:
return dict(zip(blob_ids, map(self.blob_keys.get, blob_ids))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_keys(self):\n bucket = self.resource.Bucket(self.bucketname)\n return [key.key for key in bucket.objects.all()]",
"def get_encrypted_data_keys(self, data_key, encryption_context):\n encrypted_data_keys = [message.header.EncryptedDataKey(b'aws-kms',\n ... | [
"0.6437575",
"0.6124688",
"0.61170375",
"0.5970704",
"0.5920652",
"0.5918394",
"0.5872749",
"0.5832748",
"0.58217853",
"0.58021",
"0.5690256",
"0.56733716",
"0.5656133",
"0.56275576",
"0.56275576",
"0.5610084",
"0.56076646",
"0.55941993",
"0.55817664",
"0.55722076",
"0.557199... | 0.7701036 | 0 |
Intercept http and mock client (get_repo) | def test_branch_can_be_copied():
setup_org()
setup_repo()
responses.add(responses.GET, "https://api.github.com/repos/my-org/my-repo/branches/master",
body=my_repo_branch,
content_type='text/json',
status=200)
response... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_issue_50():\n utils.set_http_mock()\n\n client = Github(proxy_host=\"my.proxy.com\", proxy_port=9000)\n setup_args = client.request._http.called_with\n assert_equals(type(setup_args['proxy_info']), httplib2.ProxyInfo)\n assert_equals(setup_args['proxy_info'].proxy_host, 'my.proxy.com')\n ... | [
"0.66696745",
"0.6602459",
"0.63437665",
"0.6236709",
"0.6184174",
"0.61553884",
"0.6148627",
"0.6107372",
"0.5980647",
"0.593272",
"0.59284574",
"0.5912947",
"0.58175915",
"0.58170277",
"0.5788988",
"0.5725378",
"0.5725306",
"0.5720646",
"0.56785136",
"0.5651482",
"0.5646013... | 0.0 | -1 |
Intercept http and mock client (get_repo) | def test_protection_can_be_copied():
setup_org("octocat")
protection_url = "https://api.github.com/repos/octocat/Hello-World/branches/master/protection"
responses.add(responses.GET, protection_url, status=200, content_type='text/json', body=branch_protection)
put_url = "https://api.github.com/repos/oc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_issue_50():\n utils.set_http_mock()\n\n client = Github(proxy_host=\"my.proxy.com\", proxy_port=9000)\n setup_args = client.request._http.called_with\n assert_equals(type(setup_args['proxy_info']), httplib2.ProxyInfo)\n assert_equals(setup_args['proxy_info'].proxy_host, 'my.proxy.com')\n ... | [
"0.6668953",
"0.6600891",
"0.63424224",
"0.62350804",
"0.61830807",
"0.6153527",
"0.61463815",
"0.6108667",
"0.5978955",
"0.59318805",
"0.5927703",
"0.59109044",
"0.58161503",
"0.5816118",
"0.57876474",
"0.5726691",
"0.57236135",
"0.5717952",
"0.5676887",
"0.5649835",
"0.5643... | 0.0 | -1 |
Supports sum([dataset1, dataset2, dataset3]). | def __radd__(self, other):
if other == 0:
return self
else:
return self.__add__(other) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum_datasets(dslist):\n #Assume all same length, same axis values\n newds = zeros_like(dslist[0])\n AddCifMetadata.add_standard_metadata(newds)\n title_info = \"\"\n proc_info = \"\"\"This dataset was created by summing points from multiple datasets. Points were \n assumed to coincide exactly... | [
"0.69257575",
"0.6655116",
"0.6303091",
"0.6137",
"0.59186286",
"0.5906148",
"0.580326",
"0.576853",
"0.576853",
"0.5768271",
"0.5721376",
"0.5690767",
"0.5661961",
"0.56405276",
"0.56123817",
"0.56020796",
"0.55628824",
"0.55342525",
"0.5516941",
"0.55149585",
"0.55093265",
... | 0.0 | -1 |
Parses data list and returns the number of person IDs and the number of camera views. | def parse_data(self, data):
pids = set()
cams = set()
for info in data:
pids.add(info[1])
cams.add(info[2])
return len(pids), len(cams) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_num_cams(self, data):\n cams = set()\n for items in data:\n camid = items[2]\n cams.add(camid)\n return len(cams)",
"def get_num_pids(self, data):\n pids = set()\n for items in data:\n pid = items[1]\n pids.add(pid)\n r... | [
"0.6483834",
"0.5873225",
"0.56902164",
"0.559616",
"0.5581715",
"0.55694574",
"0.55310565",
"0.5526454",
"0.5519276",
"0.5515513",
"0.55004495",
"0.543157",
"0.53432065",
"0.5338561",
"0.5330016",
"0.5312213",
"0.5268463",
"0.5256779",
"0.52174443",
"0.520235",
"0.5201785",
... | 0.6852167 | 0 |
Returns the number of training person identities. | def get_num_pids(self, data):
return self.parse_data(data)[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def training_set_count(self) -> int:\n return pulumi.get(self, \"training_set_count\")",
"def get_number_of_training(self):\n return self.n_train",
"def num_training_examples(self):",
"def get_nb_personne(self):\n return self.nb_personne",
"def participant_count(self) -> int:\n ... | [
"0.7130858",
"0.7117933",
"0.67800456",
"0.664693",
"0.63542926",
"0.63365936",
"0.6317348",
"0.62643784",
"0.62291634",
"0.60861695",
"0.6079785",
"0.6076607",
"0.604624",
"0.6041788",
"0.5999601",
"0.59986293",
"0.5977678",
"0.5972249",
"0.5956189",
"0.59479755",
"0.5901012... | 0.5565302 | 65 |
Returns the number of training cameras. | def get_num_cams(self, data):
return self.parse_data(data)[1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_total_cameras(self) -> int:\n return self.num_cameras",
"def get_cameras_number():\n lib.initlib()\n return lib.is_GetNumberOfCameras()",
"def ncameras(self):\n n = ct.c_long()\n self.lib.GetAvailableCameras(ct.pointer(n))\n return n.value",
"def numberOfCamera():\n ... | [
"0.8353758",
"0.80624014",
"0.7873767",
"0.7767602",
"0.7643237",
"0.7341902",
"0.73000854",
"0.71402013",
"0.67232484",
"0.6706012",
"0.6674748",
"0.6601394",
"0.65858144",
"0.6535598",
"0.6527929",
"0.64885134",
"0.6479306",
"0.6477255",
"0.6447356",
"0.6396966",
"0.6382521... | 0.0 | -1 |
Combines train, query and gallery in a dataset for training. | def combine_all(self):
combined = copy.deepcopy(self.train)
def _combine_data(data):
for img_path, pid, camid in data:
if pid in self._junk_pids:
continue
#pdb.set_trace()
pid = self.dataset_name + "_" + str(pid)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def combine_all(self):\n if self._train_only:\n return\n\n combined = copy.deepcopy(self.train)\n\n # relabel pids in gallery (query shares the same scope)\n g_pids = set()\n for items in self.gallery:\n pid = items[1]\n if pid in self._junk_pids:... | [
"0.69598746",
"0.67574775",
"0.6717249",
"0.66458243",
"0.66314375",
"0.65966815",
"0.65671974",
"0.65517074",
"0.65076643",
"0.64948964",
"0.64792395",
"0.6467504",
"0.6462277",
"0.64389426",
"0.64315575",
"0.641234",
"0.6410118",
"0.6398891",
"0.63852507",
"0.63804436",
"0.... | 0.69694567 | 0 |
Checks if required files exist before going deeper. | def check_before_run(self, required_files):
if isinstance(required_files, str):
required_files = [required_files]
for fpath in required_files:
if not os.path.exists(fpath):
raise RuntimeError('"{}" is not found'.format(fpath)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_check(self):\n for required_file in self._required_files:\n # Check if required files are there\n # FIXME Sometimes it doesn't work :?\n if required_file not in self.files:\n self.valid = False",
"def check_missing_files(self):\n files = [get... | [
"0.7485762",
"0.7367102",
"0.7227755",
"0.70789534",
"0.70283055",
"0.69488746",
"0.6946507",
"0.672183",
"0.6712726",
"0.6712726",
"0.6712726",
"0.6712726",
"0.6712726",
"0.6712726",
"0.6712726",
"0.6698533",
"0.66718006",
"0.66628796",
"0.6643828",
"0.6639172",
"0.66012675"... | 0.7092478 | 3 |
Perform an insert or update. | def _do_upsert(self, conn, item, spider):
query_check = "select * from %s where url = %%s" % spider.name
conn.execute(query_check, (item['url'], ))
result = conn.fetchone()
if result:
query_udpate = "UPDATE %s SET price=%ss" % spider.name
conn.execute(query_udpate, (item['pri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insert_or_update(self, table, record):\n try:\n request = s.query(table=table, query={'sys_id': record['sys_id']})\n #request.get_single()\n response = request.update(record)\n print >> sys.stderr, 'update'\n except NoResults:\n # Record does... | [
"0.6802625",
"0.6760875",
"0.67485595",
"0.66731614",
"0.66411924",
"0.621796",
"0.6103661",
"0.60958934",
"0.6045349",
"0.6037797",
"0.6003509",
"0.60019463",
"0.5977113",
"0.59489703",
"0.5928445",
"0.5923789",
"0.59120774",
"0.5863009",
"0.58497566",
"0.582207",
"0.5809673... | 0.54526764 | 80 |
Assigns every training point a weight equal to 1/N, where N is the number of training points. Returns a dictionary mapping points to weights. | def initialize_weights(training_points):
N = len(training_points)
ans = {}
for p in training_points:
ans[p] = make_fraction(1, N)
return ans | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def default_weights(n):\n return np.array([1/n for _ in range(n)])",
"def uniform_weights(n):\n return np.ones((n, 1)) / n",
"def update_weights(point_to_weight, misclassified_points, error_rate):\n for p in point_to_weight:\n if p in misclassified_points:\n point_to_weight[p] *= mak... | [
"0.6437919",
"0.6396687",
"0.624045",
"0.61508226",
"0.6023781",
"0.6023781",
"0.5951131",
"0.59024775",
"0.58835477",
"0.58784914",
"0.5861894",
"0.58606887",
"0.5855883",
"0.5820768",
"0.5816859",
"0.5815168",
"0.58121",
"0.57764375",
"0.57757556",
"0.5774974",
"0.5753624",... | 0.8002009 | 0 |
Given a dictionary mapping training points to their weights, and another dictionary mapping classifiers to the training points they misclassify, returns a dictionary mapping classifiers to their error rates. | def calculate_error_rates(point_to_weight, classifier_to_misclassified):
ans = {}
for c in classifier_to_misclassified:
misclassified = classifier_to_misclassified[c]
ans[c] = 0
for p in misclassified:
ans[c] += point_to_weight[p]
return ans | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_weights(point_to_weight, misclassified_points, error_rate):\n for p in point_to_weight:\n if p in misclassified_points:\n point_to_weight[p] *= make_fraction(1,2)*make_fraction(1, error_rate)\n else:\n point_to_weight[p] *= make_fraction(1,2)*make_fraction(1, 1-err... | [
"0.6313117",
"0.5606973",
"0.55354184",
"0.55307525",
"0.5491061",
"0.54466426",
"0.5413339",
"0.5376725",
"0.5321494",
"0.5300928",
"0.5286332",
"0.52586734",
"0.5237726",
"0.5230793",
"0.52304846",
"0.5226977",
"0.5218962",
"0.5217092",
"0.51976115",
"0.5183116",
"0.5169867... | 0.76960677 | 0 |
Given a dictionary mapping classifiers to their error rates, returns the best classifier, or raises NoGoodClassifiersError if best classifier has error rate 1/2. best means 'smallest error rate' if use_smallest_error is True, otherwise 'error rate furthest from 1/2'. | def pick_best_classifier(classifier_to_error_rate, use_smallest_error=True):
best_classifier = None
if use_smallest_error:
best_classifier = min(classifier_to_error_rate, key=classifier_to_error_rate.get)
else:
best_classifier = max(classifier_to_error_rate, key=lambda x : abs(classifier_to_erro... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_best_classifier(data, possible_classifiers, target_classifier):\n best_disorder_score = 10000000\n best_classifier = None\n try:\n for classifier in possible_classifiers:\n total_disorder = average_test_disorder(data, classifier, target_classifier)\n if total_disorder... | [
"0.65992683",
"0.6348734",
"0.60387164",
"0.56676745",
"0.5634381",
"0.5621993",
"0.55739546",
"0.55624396",
"0.5539638",
"0.5454468",
"0.5443642",
"0.5441887",
"0.5408296",
"0.53730357",
"0.531757",
"0.526106",
"0.5247903",
"0.52269906",
"0.52153784",
"0.52098244",
"0.519527... | 0.80622786 | 0 |
Given a classifier's error rate (a number), returns the voting power (aka alpha, or coefficient) for that classifier. | def calculate_voting_power(error_rate):
if error_rate == 0:
return INF
if error_rate == 1:
return -INF
return 0.5*ln(make_fraction(1-error_rate, error_rate)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exponential_vote(score, category):\n status = \"\"\n\n try:\n max_vote = constants.MAX_VOTE[category]\n except:\n max_vote = constants.MAX_TASK_REQUEST\n\n else:\n power = constants.EXP_POWER\n weight = pow(\n score / 100.0,\n power - (score / 100.0... | [
"0.6483174",
"0.60067403",
"0.58584934",
"0.57399225",
"0.5617777",
"0.55273247",
"0.5520179",
"0.5502458",
"0.5488472",
"0.54872227",
"0.5482623",
"0.5475527",
"0.5460961",
"0.5439238",
"0.54219",
"0.54015714",
"0.53638995",
"0.53533477",
"0.53349483",
"0.5307904",
"0.529213... | 0.7368655 | 0 |
Given an overall classifier H, a list of all training points, and a dictionary mapping classifiers to the training points they misclassify, returns a set containing the training points that H misclassifies. H is represented as a list of (classifier, voting_power) tuples. | def get_overall_misclassifications(H, training_points, classifier_to_misclassified):
misclassified = []
for p in training_points:
score = 0
for tup in H:
c = tup[0]
voting_power = tup[1]
if p in classifier_to_misclassified[c]:
score -= voting_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def misclassified_training_points(svm):\n wrong = []\n for point in svm.training_points:\n if point.classification is not classify(svm, point):\n wrong.append(point)\n return set(wrong)",
"def digits_make_classifiers_to_misclassified(X,Y,classifiers,ids_to_points):\n\toutput = {key: []... | [
"0.7052224",
"0.6119313",
"0.54236513",
"0.5231023",
"0.5223641",
"0.51209354",
"0.510333",
"0.5085148",
"0.5023613",
"0.5006669",
"0.49687526",
"0.4961643",
"0.49522075",
"0.49459502",
"0.49397606",
"0.49372053",
"0.49112162",
"0.48705956",
"0.48250222",
"0.48217845",
"0.481... | 0.85402024 | 0 |
Given an overall classifier H, a list of all training points, a dictionary mapping classifiers to the training points they misclassify, and a mistake tolerance (the maximum number of allowed misclassifications), returns False if H misclassifies more points than the tolerance allows, otherwise True. H is represented as ... | def is_good_enough(H, training_points, classifier_to_misclassified, mistake_tolerance=0):
misclassified = get_overall_misclassifications(H, training_points, classifier_to_misclassified)
if len(misclassified) > mistake_tolerance:
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_overall_misclassifications(H, training_points, classifier_to_misclassified):\n misclassified = []\n\n for p in training_points:\n score = 0\n for tup in H:\n c = tup[0]\n voting_power = tup[1]\n if p in classifier_to_misclassified[c]:\n sc... | [
"0.68727624",
"0.59430206",
"0.58152044",
"0.5540413",
"0.55316037",
"0.5448521",
"0.5405066",
"0.5398594",
"0.5388817",
"0.5313519",
"0.53004795",
"0.5284414",
"0.5269668",
"0.5265305",
"0.5240204",
"0.5234198",
"0.520831",
"0.5201402",
"0.5200734",
"0.51976657",
"0.5176463"... | 0.7659174 | 0 |
Given a dictionary mapping training points to their old weights, a list of training points misclassified by the current weak classifier, and the error rate of the current weak classifier, returns a dictionary mapping training points to their new weights. This function is allowed (but not required) to modify the input d... | def update_weights(point_to_weight, misclassified_points, error_rate):
for p in point_to_weight:
if p in misclassified_points:
point_to_weight[p] *= make_fraction(1,2)*make_fraction(1, error_rate)
else:
point_to_weight[p] *= make_fraction(1,2)*make_fraction(1, 1-error_rate)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_error_rates(point_to_weight, classifier_to_misclassified):\n ans = {}\n for c in classifier_to_misclassified:\n misclassified = classifier_to_misclassified[c]\n ans[c] = 0\n for p in misclassified:\n ans[c] += point_to_weight[p]\n return ans",
"def keypoint_... | [
"0.67305875",
"0.58836514",
"0.5748413",
"0.5478308",
"0.54563385",
"0.53294194",
"0.5201591",
"0.51845413",
"0.5084596",
"0.50814384",
"0.5060465",
"0.50252044",
"0.5015587",
"0.50075173",
"0.49619642",
"0.49579272",
"0.49395669",
"0.4937159",
"0.49219316",
"0.490734",
"0.48... | 0.78441054 | 0 |
Performs the Adaboost algorithm for up to max_rounds rounds. Returns the resulting overall classifier H, represented as a list of (classifier, voting_power) tuples. | def adaboost(training_points, classifier_to_misclassified,
use_smallest_error=True, mistake_tolerance=0, max_rounds=INF):
point_to_weight = initialize_weights(training_points)
H = [] # (classifier, voting_power)
while True:
# exit conditions
if is_good_enough(H, training_points... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def modelAdaBoost():\n num_estimators = [1,5,10,50,100,150]\n learning_rate = 0.1\n max_depth = 3\n base_estimate = DecisionTreeClassifier(max_depth=max_depth)\n random_state = 20 # Do not change this random_state\n \n obj_boost = []\n \n \"\"\" \n Create a list of objects for the cla... | [
"0.5816989",
"0.5509983",
"0.541834",
"0.53876275",
"0.53350043",
"0.5324034",
"0.5317509",
"0.5210553",
"0.51253355",
"0.51249367",
"0.5117827",
"0.50774145",
"0.50676054",
"0.5053001",
"0.5049434",
"0.50463754",
"0.50307447",
"0.5024344",
"0.50045466",
"0.4988225",
"0.49871... | 0.6702093 | 0 |
Create a plane through a given point with given normal and surface material | def __init__(self, point, normal, material):
self.point = point
self.norm = unit(normal)
self.mat = material | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def project_point_plane(point, plane):\n base, normal = plane\n normal = normalize_vector(normal)\n vector = subtract_vectors(point, base)\n snormal = scale_vector(normal, dot_vectors(vector, normal))\n return subtract_vectors(point, snormal)",
"def plot_plane(unit_normal, x_array, y_array, fore):... | [
"0.6926132",
"0.67918247",
"0.66280645",
"0.6622853",
"0.6570255",
"0.6499382",
"0.64442146",
"0.6332076",
"0.62797856",
"0.62646264",
"0.6246257",
"0.6151091",
"0.6120761",
"0.6096576",
"0.60693115",
"0.59628874",
"0.5912617",
"0.58920056",
"0.58715844",
"0.585937",
"0.58575... | 0.683124 | 1 |
Returns a hit, or None if the ray is parallel to the plane | def intersect(self, ray):
t = None
hit = None
angle = ray.dir.dot(self.norm)
if angle != 0:
t = (self.point - ray.start).dot(self.norm) / angle
if angle < 0:
hit = Hit(self, ray, t, float('inf'), self.norm, self.mat)
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rayIntersection(self, ray):\n #t = \"what we are trying to find\"\n l = -ray.mDirection\n l0 = ray.mOrigin\n n = self.mNormal\n p0 = self.mDistance * n\n #p = l0 + l * t\n\n if l.dot(n) > 0:\n v = p0 - l0\n t = -(v.dot(n) / l.dot(n))\n ... | [
"0.724688",
"0.7169482",
"0.7158089",
"0.71482855",
"0.67915195",
"0.67516196",
"0.67201257",
"0.66962445",
"0.6689992",
"0.6683316",
"0.65686566",
"0.6530607",
"0.64233273",
"0.6218107",
"0.6107053",
"0.60904384",
"0.60822034",
"0.60539466",
"0.60471374",
"0.5973455",
"0.595... | 0.7633641 | 0 |
return the number of scalar components | def getNumberOfScalarComponents(self):
return self.numberOfComponents | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def n_components(self):\n return 1",
"def n_components(self):\n return self._components.shape[0]",
"def n_cs(self):\n return np.size(self._cs, 0)",
"def components(self):\n return self.num_components",
"def __len__(self):\n num_x, num_y = self.conv_dims()\n return ... | [
"0.74888134",
"0.7376706",
"0.7100258",
"0.70853853",
"0.70716816",
"0.6938483",
"0.69184744",
"0.68926495",
"0.68802017",
"0.68690693",
"0.6788687",
"0.67648643",
"0.6762822",
"0.6739765",
"0.67380327",
"0.67363364",
"0.671714",
"0.6700786",
"0.66510797",
"0.6639145",
"0.663... | 0.8905581 | 0 |
Set the color transfer function | def setColorTransferFunction(self, ctf):
self.ctf = ctf | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_color(self):\r\n \r\n \r\n colorset = self.colorset\r\n \r\n self.grfx[0].colorset = colorset\r\n pass",
"def setColorDiffuse(*args):",
"def getColorTransferFunction(self):\n\t\treturn self.ctf",
"def set_color(self):\n self.image[self.x, self.y] = self.color\n if s... | [
"0.67156917",
"0.6633878",
"0.6617592",
"0.63400304",
"0.6332681",
"0.6234133",
"0.62047946",
"0.6202683",
"0.61825573",
"0.60994345",
"0.6095942",
"0.601829",
"0.5967596",
"0.5921991",
"0.5918888",
"0.5858037",
"0.5846267",
"0.5846243",
"0.5836248",
"0.5822841",
"0.5788105",... | 0.81864583 | 0 |
Return a flag indicating whether the images are 2D or 3D images | def is3DImage(self):
return self.is3D | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_depth_image(self):\n return False",
"def is_2d(self) -> bool:\n return self.layers == 1 and self.times == 1",
"def check_niimg_3d(niimg, dtype=None):\n return check_niimg(niimg, ensure_ndim=3, dtype=dtype)",
"def is3_d(self):\n return self.container['is3_d']",
"def are_compat... | [
"0.68862396",
"0.65322673",
"0.6502295",
"0.64808524",
"0.64616615",
"0.64155763",
"0.63741845",
"0.6256185",
"0.62417966",
"0.6234979",
"0.6150245",
"0.6141367",
"0.60545796",
"0.6043418",
"0.603095",
"0.60253567",
"0.5992711",
"0.5932484",
"0.5897953",
"0.5897953",
"0.58671... | 0.7844598 | 0 |
set the filenames that will be read | def setFilenames(self, filenames):
self.filenames = filenames
if len(filenames) == 0:
return
if not self.dimensions:
self.retrieveImageInfo(filenames[0])
if not self.checkImageDimensions(filenames):
raise Logging.GUIError("Image dimensions do not match", \
"Some of the selected files have di... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_filename(self, file_name):",
"def setfiles(self, filelist):\r\n self._filelist=filelist\r\n self._energy=self.readenergy(filelist)",
"def filenames(self):\n pass",
"def fileset(self):\n pass",
"def __init__(self, files):\n self.files = files and [NamedFile(data=d, filenam... | [
"0.6955265",
"0.6887402",
"0.6878499",
"0.67892617",
"0.6675026",
"0.6572736",
"0.65357256",
"0.65231085",
"0.64586145",
"0.64167434",
"0.6371263",
"0.6240702",
"0.6175739",
"0.6168266",
"0.61507344",
"0.6141928",
"0.61352116",
"0.6123154",
"0.6068659",
"0.6062177",
"0.605273... | 0.72363704 | 0 |
Set a flag indicating whether the image should be flipped vertically | def setVerticalFlip(self, flag):
if self.ext.lower() in ["png", "jpg", "jpeg"]:
self.flipVertically = not flag
else:
self.flipVertically = flag | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flip_vertical(img):\r\n #reading image\r\n im = Image.open(\"filename\")\r\n\r\n #flipping image vertically\r\n newimg = im.transpose(PIL.Image.FLIP_TOP_BOTTOM)\r\n return img",
"def flip_image_vertical(image):\n return cv.flip(image, 1)",
"def flip_image(img, vert=True):\n if vert:\n ... | [
"0.73209965",
"0.70142406",
"0.68551445",
"0.66779745",
"0.66683435",
"0.666765",
"0.65579903",
"0.64983195",
"0.64376324",
"0.64257395",
"0.6424698",
"0.6389282",
"0.63263226",
"0.63111866",
"0.63103646",
"0.630324",
"0.6244989",
"0.61426216",
"0.6092576",
"0.60797507",
"0.6... | 0.8431753 | 0 |
Set a flag indicating whether the image should be flipped horizontally | def setHorizontalFlip(self, flag):
self.flipHorizontally = flag | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flip_horizontal(img):\r\n #reading image\r\n im = Image.open(\"filename\")\r\n\r\n #flipping image horizontally\r\n newimg = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\r\n \r\n return img",
"def flip_image_horizontal(image):\n return cv.flip(image, 0)",
"def flip(self, horizontally):\n\t\... | [
"0.7160271",
"0.6985837",
"0.6883737",
"0.6870575",
"0.6787338",
"0.67704475",
"0.6695351",
"0.6677402",
"0.6635156",
"0.6454874",
"0.64387655",
"0.64263225",
"0.6393341",
"0.6339728",
"0.63132757",
"0.6289396",
"0.61795443",
"0.61762446",
"0.61736774",
"0.6157254",
"0.614742... | 0.83549047 | 0 |
check that each image in the list has the same dimensions | def checkImageDimensions(self, filenames):
s = None
hashStr = filenames[:]
hashStr.sort()
hashStr = str(hashStr)
# check to see if there's already a result of the check for these filenames in the cache
if hashStr in self.dimensionCheck:
Logging.info("Using cached result for dimensions check: %s"%(str(sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def images_are_present(file_info):\n currentdir = os.path.join(WORKDIR, file_info['folder'])\n if not os.path.exists(currentdir):\n return False\n count = len([x for x in os.listdir(currentdir) if x.endswith('.png')])\n if count != file_info['size']:\n print([x for x in os.listdir(current... | [
"0.66642034",
"0.6607947",
"0.65018415",
"0.6470456",
"0.64090717",
"0.63401216",
"0.6332631",
"0.63291144",
"0.6313849",
"0.6313849",
"0.62913483",
"0.6274798",
"0.62315774",
"0.6190616",
"0.6132303",
"0.6132303",
"0.6086374",
"0.60784054",
"0.6073663",
"0.60491264",
"0.6013... | 0.66137314 | 1 |
return a VTK image reader based on file extension | def getReaderByExtension(self, ext, isRGB = 0):
assert ext in self.extMapping, "Extension not recognized: %s" % ext
mpr = self.extMapping[ext]
prefix="vtk"
# If it's a tiff file, we use our own, extended TIFF reader
if self.extMapping[ext] == "TIFF":
mpr = "ExtTIFF"
prefix="vtkbxd"
self.rdrstr = "%s.v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getReadersFromFilenames(self):\n\t\tfor i in self.readers:\n\t\t\tdel i\n\t\tself.readers = []\n\n\t\tif not self.filenames:\n\t\t\traise Logging.GUIError(\"No files could be found\", \\\n\t\t\t\t\t\t\t\t\t\"For some reason, no files were listed to be imported.\")\t\t \n\t\t\t\t\t\n\t\tfiles = self.filenames\n... | [
"0.64241487",
"0.5978514",
"0.59677935",
"0.5905505",
"0.5868323",
"0.5654292",
"0.5641504",
"0.5602225",
"0.5563264",
"0.55544156",
"0.55478626",
"0.55258757",
"0.5498806",
"0.54907084",
"0.5490219",
"0.5475998",
"0.5461645",
"0.5444304",
"0.54409236",
"0.541251",
"0.5400047... | 0.75270355 | 0 |
create the reader list from a given set of file names and parameters | def getReadersFromFilenames(self):
for i in self.readers:
del i
self.readers = []
if not self.filenames:
raise Logging.GUIError("No files could be found", \
"For some reason, no files were listed to be imported.")
files = self.filenames
print "Determining readers from ", self.filename... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_file_readers():\n savefile_path = os.path.join(os.getcwd()+ \"/../data/\", SAVE_FILE)\n file_reader_list = []\n for file in os.listdir(savefile_path):\n file_reader = open(os.path.join(savefile_path,file), \"r\")\n file_reader_list.append({\"file_reader\": file_reader, \"last... | [
"0.6492544",
"0.63382894",
"0.6250799",
"0.611366",
"0.6069598",
"0.6018633",
"0.59182394",
"0.5909983",
"0.58632267",
"0.58579755",
"0.5853619",
"0.5849561",
"0.5829838",
"0.580928",
"0.57897955",
"0.5785899",
"0.57765526",
"0.57752377",
"0.57527864",
"0.57526433",
"0.574977... | 0.679022 | 0 |
return the number of slices per timepoint | def getSlicesPerTimepoint(self):
return self.slicesPerTimepoint | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getDataSetCount(self):\n\t\treturn int(self.numberOfImages / self.slicesPerTimepoint)",
"def size(self):\n size = 1\n for current_slice in self.slices:\n size *= current_slice.stop - current_slice.start\n return size",
"def n(self):\n return self._time_axis.size",
"... | [
"0.7135924",
"0.6884999",
"0.64077276",
"0.6373212",
"0.6304518",
"0.6302463",
"0.6214839",
"0.6137181",
"0.6126625",
"0.61182857",
"0.6099939",
"0.6055298",
"0.6052316",
"0.6023152",
"0.59912443",
"0.5985234",
"0.59840417",
"0.59639126",
"0.59609234",
"0.59437424",
"0.594127... | 0.76755035 | 0 |
Set the number of slices that belong to a given timepoint | def setSlicesPerTimepoint(self, n):
assert n > 0, "Slices per timepoint needs to be greater than 0"
print "Setting slices per timepoint to ", n
self.slicesPerTimepoint = n
self.z = n
self.readers = [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setNSlices(self,n):\n assert(n> 0)\n self._c_param.lee_richards_n_slices = n",
"def setNumTimeSubSteps(*argv):",
"def getSlicesPerTimepoint(self):\n\t\treturn self.slicesPerTimepoint",
"def _set_window_time(slices, times):\n t_idx_ = [t[-1] for t in slices]\n return times[t_idx_]",
... | [
"0.6350953",
"0.6137186",
"0.58842385",
"0.5869937",
"0.56822366",
"0.56016797",
"0.5523093",
"0.5513194",
"0.54768455",
"0.5377458",
"0.5337342",
"0.5313137",
"0.5259041",
"0.5251777",
"0.52457607",
"0.5220166",
"0.5212587",
"0.52124",
"0.52096623",
"0.5208932",
"0.52069575"... | 0.7975833 | 0 |
Returns the number of individual DataSets (=time points) managed by this DataSource | def getDataSetCount(self):
return int(self.numberOfImages / self.slicesPerTimepoint) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(self):\n return self.data_container.count",
"def get_num_datasets(self, data):\n dsets = set()\n for items in data:\n dsetid = items[3]\n dsets.add(dsetid)\n return len(dsets)",
"def count_data(self):\n try:\n ndata = len(self.x)\n ... | [
"0.7276192",
"0.7221659",
"0.72136873",
"0.7015325",
"0.69837743",
"0.68426126",
"0.6835689",
"0.6830701",
"0.6756762",
"0.66132236",
"0.6597357",
"0.65931714",
"0.65570873",
"0.6531572",
"0.6491252",
"0.64376664",
"0.6436097",
"0.6429143",
"0.642638",
"0.6403021",
"0.6397654... | 0.79010725 | 0 |
Timepoint i i The timepoint to return | def getDataSet(self, i, raw = 0):
data = self.getTimepoint(i)
if self.isRGB and self.numberOfComponents == 4:
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0, 1, 2)
extract.SetInput(data)
data = extract.GetOutput()
if self.flipVertically:
flip = vtk.vtkImageFlip()
flip.SetFilt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_time_points(self):\n return self._time",
"def time(self):\r\n raise NotImplementedError",
"def setTimepoint(self, tp):\n\t\tpass",
"def time(self):\n return self._begin",
"def t0(self):\n return self._time_axis.start",
"def get_time(self):\n start=''\n end=''... | [
"0.679934",
"0.6443112",
"0.64257336",
"0.64229566",
"0.6388925",
"0.63801783",
"0.6370203",
"0.6363844",
"0.63452727",
"0.6335522",
"0.63265383",
"0.63182783",
"0.63152707",
"0.6278807",
"0.61801505",
"0.61801505",
"0.61801505",
"0.6171835",
"0.6104696",
"0.6076395",
"0.6036... | 0.0 | -1 |
A method that reads information from an image | def retrieveImageInfo(self, filename):
assert filename, "Filename must be defined"
assert os.path.exists(filename), "File that we're retrieving information \
from (%s) needs to exist, but doesn't." % filename
self.ext = filename.split(".")[-1].lower()
rdr = self.getReaderByExtension(self.ext)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def image_info(img):\n\tprint(img.format)\n\tprint(img.size)\n\tprint(img.mode)",
"def test_read_image(self):\n pass",
"def image_info(path):\n global working_img\n working_img = Image.open(path)\n print('=======================================')\n print(f'이미지 파일 이름:{working_img.filename}')\... | [
"0.72628486",
"0.72226435",
"0.6992954",
"0.6965782",
"0.6876386",
"0.68329227",
"0.6822123",
"0.68075496",
"0.6758192",
"0.6675034",
"0.6649149",
"0.6627219",
"0.6605855",
"0.660208",
"0.6594365",
"0.65857846",
"0.6574458",
"0.6571832",
"0.6551282",
"0.65477014",
"0.65150887... | 0.64804757 | 25 |
Return the nth timepoint | def getTimepoint(self, n, onlyDims = 0):
if not self.readers:
self.getReadersFromFilenames()
if self.is3DImage():
if not self.readers:
raise Logging.GUIError("Attempt to read bad timepoint", "Timepoint %d is not defined by the given filenames" % n)
self.reader = self.readers[0]
minZ = n * self.slic... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nthPersonGetsNthSeat(self, n: int) -> float:\n if n == 1:\n return 1.0\n\n return 1 / 2",
"def get_second(time_index):\n return np.array(time_index.second).reshape(-1,1)",
"def get_times_slice(self, index, next_index):\n next_index = tf.minimum(next_index, self.Nt)\n ... | [
"0.6113835",
"0.6054137",
"0.5898435",
"0.58786285",
"0.58263016",
"0.57462263",
"0.5740125",
"0.5694311",
"0.5676445",
"0.56450284",
"0.5632503",
"0.55841124",
"0.5574055",
"0.55318683",
"0.55112934",
"0.5497918",
"0.54749393",
"0.54705596",
"0.5468096",
"0.5458759",
"0.5441... | 0.59078765 | 2 |
Returns the (x,y,z) dimensions of the datasets this dataunit contains | def getDimensions(self):
print "Returning",self.x,self.y,self.slicesPerTimepoint
return (self.x, self.y, self.slicesPerTimepoint) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getDimensions():",
"def dimensions():",
"def get_data_dimensions(self):\n return image_utils.convert_shape_indexing(self._get_data_dimensions_rc(),\"rc\",self.image_indexing)",
"def get_dimensions(self):\r\n x = []\r\n y = []\r\n z = []\r\n for i in self.verts:\r\n ... | [
"0.7814758",
"0.77764654",
"0.77693594",
"0.76322365",
"0.74653226",
"0.7423212",
"0.7418739",
"0.7339198",
"0.7303002",
"0.7278066",
"0.7271514",
"0.72714305",
"0.7247757",
"0.7213372",
"0.7206813",
"0.71931577",
"0.7168946",
"0.7104327",
"0.71030354",
"0.7093483",
"0.708581... | 0.7157837 | 17 |
Returns the spacing of the datasets this dataunit contains | def getSpacing(self):
if not self.spacing:
a, b, c = self.getVoxelSize()
self.spacing = [1, b / a, c / a]
return self.spacing | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetSpacing(self):\r\n\r\n return self._spacing",
"def spacings(self):\n return np.array([self.pixel_spacing,\n self.pixel_spacing,\n self.slice_spacing])",
"def spacing(self):\r\n\r\n return self.dx, self.dy, self.dz",
"def margin(self)... | [
"0.69162726",
"0.6651873",
"0.66186863",
"0.6618427",
"0.6541836",
"0.64272296",
"0.6390034",
"0.6284166",
"0.6187805",
"0.61713886",
"0.6085297",
"0.6026972",
"0.6021646",
"0.60199386",
"0.5960843",
"0.5940496",
"0.59104943",
"0.5868685",
"0.573976",
"0.5731771",
"0.57220376... | 0.7266339 | 0 |
Returns the voxel size of the datasets this dataunit contains | def getVoxelSize(self):
return self.voxelsize | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def voxel_size(self):\n return self.calculation.voxel_size",
"def dataset_size(self):\n return self.dataset.size",
"def GetVoxelSize(vDataSet):\r\n nx = vDataSet.GetSizeX()\r\n ny = vDataSet.GetSizeY()\r\n nz = vDataSet.GetSizeZ()\r\n\r\n if nx > 0: nx = abs(vDataSet.GetExtendMaxX()-v... | [
"0.8266003",
"0.76687074",
"0.7574417",
"0.75476074",
"0.7534628",
"0.7282379",
"0.72617334",
"0.7169072",
"0.7134597",
"0.7131639",
"0.71055424",
"0.7064898",
"0.70379966",
"0.7025604",
"0.7004166",
"0.6994787",
"0.69689655",
"0.69596523",
"0.6953735",
"0.69417727",
"0.69085... | 0.7754449 | 1 |
set the voxel sizes of the images that are read | def setVoxelSize(self, vxs):
self.voxelsize = vxs
a, b, c = vxs
self.spacing = [1, b / a, c / a] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _assign_sizes(self):",
"def setinputsizes(self, sizes):\n pass",
"def setImageDimensions(*args):",
"def update_size(self):\n self.size = self.image.size\n self.width, self.height = self.size",
"def set_size(self, size=None):\n if not size:\n size = self.output_siz... | [
"0.66988456",
"0.6689091",
"0.6536548",
"0.61790437",
"0.6176843",
"0.61598647",
"0.6149251",
"0.6120889",
"0.6050634",
"0.6040322",
"0.60017174",
"0.59967524",
"0.59520566",
"0.5908052",
"0.58848417",
"0.5881362",
"0.5838115",
"0.5830686",
"0.5829773",
"0.57882386",
"0.57879... | 0.7176527 | 0 |
Loads the specified .oif file and imports data from it. | def loadFromFile(self, filename):
return [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data(self) -> None:",
"def _load(self):\n op_type_file_path = os.path.join(\n self._profiling_dir,\n self._csv_file_to_analyse.format(self._device_id)\n )\n op_type_file_path = validate_and_normalize_path(\n op_type_file_path, raise_key=\"Invalid op_... | [
"0.6358744",
"0.62189686",
"0.6196685",
"0.6185245",
"0.6043738",
"0.5999552",
"0.59746337",
"0.5964088",
"0.5944215",
"0.5927775",
"0.5897965",
"0.58831894",
"0.5869329",
"0.5848849",
"0.58181727",
"0.5810083",
"0.5804512",
"0.577736",
"0.576331",
"0.57621175",
"0.5762104",
... | 0.0 | -1 |
Returns the name of the dataset series which this datasource operates on | def getName(self):
return self.name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dataset_name(self):\n return self.dataset.name",
"def get_dataset_name(self):\n raise NotImplementedError",
"def get_dataset_name(self):\n return self.dataset_name",
"def dataset_name(self):\n return self._dataset_name",
"def series_names(self):\r\n return self.names"... | [
"0.76386154",
"0.7613764",
"0.7546239",
"0.75300765",
"0.7156447",
"0.6760011",
"0.6729094",
"0.6698387",
"0.66739553",
"0.6590775",
"0.6491004",
"0.64055467",
"0.6366336",
"0.63660336",
"0.63432425",
"0.63402456",
"0.63139105",
"0.6290302",
"0.6242632",
"0.62166566",
"0.6213... | 0.0 | -1 |
Returns the ctf of the dataset series which this datasource operates on | def getColorTransferFunction(self):
return self.ctf | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getCDF(self):\n return self.cdfSample",
"def CFL(self):\n return self.__CFL",
"def get_cffts(self):\n return [\n rfft(self.nx, self.dx, fft=self.tfft, ny=self.ny,\n dy=self.dy).get_cfft(),\n rfft(self.nx, self.dx, fft=self.efft, ny=self.ny,\n ... | [
"0.6114998",
"0.5954782",
"0.5948087",
"0.5920047",
"0.59179395",
"0.58852816",
"0.5781732",
"0.57313186",
"0.57007056",
"0.56663144",
"0.5602908",
"0.5576217",
"0.55340517",
"0.5467268",
"0.5431777",
"0.539905",
"0.539905",
"0.5388791",
"0.5385939",
"0.53720737",
"0.53636706... | 0.5846474 | 6 |
Returns number of images in this data source. | def getNumberOfImages(self):
return self.numberOfImages | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_image_count(self):\n return self._num_images",
"def get_num_of_images(self):",
"def num_of_images(self):\n return len(self.data['image_infos'])",
"def numberOfImages(self):\n return len(self.imageList)",
"def __len__(self):\n return self.num_images",
"def __len__(self)... | [
"0.84259796",
"0.83975625",
"0.83702207",
"0.80581206",
"0.77916324",
"0.77916324",
"0.77916324",
"0.77916324",
"0.77916324",
"0.77843183",
"0.7672272",
"0.7612054",
"0.74140126",
"0.7412375",
"0.72965276",
"0.7274649",
"0.7274649",
"0.72326416",
"0.72228235",
"0.7218599",
"0... | 0.85196555 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.