import time
from agd.AutomaticDifferentiation.Optimization import norm_infinity
from packaging import version
from agd import AutomaticDifferentiation as ad
np.set_printoptions(edgeitems=30,
linewidth=100000,
formatter=dict(float=lambda x: "%5.3g" % x))
n = 200
hfmIn = HFMUtils.dictIn({
'model': 'Isotropic2',
'seeds': [[0., 0.]],
'verbosity': 0,
'exportGeodesicFlow': 1,
'geodesic_hlen': 20,
'array_float_caster': cp.asarray,
'geodesic_traits': {
'debug_print': 1,
},
})
hfmIn.SetRect([[-1, 1], [-1, 1]], dimx=n + 1, sampleBoundary=True)
X = hfmIn.Grid()
hfmIn.update({
'cost': np.prod(np.sin(2 * np.pi * X), axis=0) + 1.1, # Non-constant cost
'tips': hfmIn.Grid(dims=(5, 4)).reshape(2, -1).T
})
hfmIn['tips'] = hfmIn['tips'][:1, :]
gpuOut = hfmIn.RunGPU()
hfmIn = HFMUtils.dictIn({
'model': 'Isotropic2',
'exportValues': 1,
# 'order':2,
# 'verbosity':1,
'seeds': [[0, 0]],
# 'kernel':"dummy",
# 'solver':'AGSI',
# 'solver':'global_iteration',
'raiseOnNonConvergence': False,
'nitermax_o': 8,
# 'tol':1e-8,
# 'multiprecision':True,
# 'values_float64':True,
# 'help':['nitermax_o','traits'],
'dims': np.array((n, n)),
'origin': [-0.5, -0.5],
'gridScale': 1.,
# 'order':2,
# 'order2_threshold':0.3,
# 'factoringRadius':10000,
# 'seedRadius':2,
# 'returns':'in_raw',
# 'bound_active_blocks':True,
'traits': {
'niter_i': 8,
'shape_i': (4, 4),
# 'niter_i':1,'shape_i':(8,8),
# 'niter_i':16,'shape_i':(8,8),
# 'niter_i':32,'shape_i':(16,16),
# 'niter_i':48,'shape_i':(24,24),
# 'niter_i':64,'shape_i':(32,32),
# 'debug_print':1,
# 'niter_i':1,
# 'strict_iter_i_macro':1,
# 'pruning_macro':1,
# 'strict_iter_o_macro':1,
},
'forwardAD_traits': {
'debug_print': 1
},
})
from packaging import version
from agd import AutomaticDifferentiation as ad
np.set_printoptions(edgeitems=30, linewidth=100000,
formatter=dict(float=lambda x: "%5.3g" % x))
n=201
hfmIn = HFMUtils.dictIn({
'model':'Isotropic2',
'seeds':[[0.,0.]],
'exportValues':1,
'cost':cp.array(1.,dtype=np.float32),
'exportGeodesicFlow':1,
'tips':[[1,1]],
'traits':{
# 'niter_i':16,'shape_i':(8,8),
# 'debug_print':1,
},
'geodesic_traits':{
# 'debug_print':1,
},
# 'geodesic_typical_len':25,
# 'geodesic_max_len':40,
})
hfmIn.SetRect([[-1,1],[-1,1]],dimx=n+1,sampleBoundary=True)
gpuOut = hfmIn.RunGPU()
#print("flow",gpuOut['flow'])
print("geodesics : ",gpuOut['geodesics'])
print("stopping criteria : ",gpuOut['geodesic_stopping_criteria'])
HFMUtils.dictIn.RunSmart = cugen.cupy_get_args(HFMUtils.RunSmart,
dtype64=True,
iterables=(dict, Metrics.Base))
xp = cp
n = 7
hfmIn_Constant = HFMUtils.dictIn({
'model': 'TTI2',
'arrayOrdering': 'RowMajor',
'exportValues': 1,
'seeds': xp.array([[0., 0.]]),
# 'factoringMethod':'Static',
'nitermax_o': 1,
'factoringRadius': 10,
'nitermax_o': 1,
# 'seedRadius':2,
'order': 2,
'traits': {
'debug_print': 1,
'nmix': 2,
},
'raiseOnNonConvergence': False
# 'tips':[[x,y] for y in HFMUtils.CenteredLinspace(-1,1,6)
# for x in HFMUtils.CenteredLinspace(-1,1,6)],
# 'exportGeodesicFlow':1,
})
hfmIn_Constant.SetRect(sides=[[0, 1], [0, 1]], dimx=n + 1,
sampleBoundary=True) # Define the domain
X = hfmIn_Constant.Grid() # Horizontal and vertical axis
quad = xp.array([[0.5, 0.1], [0.1, -0.2]])
hfmIn = HFMUtils.dictIn({
'model': 'Riemann2',
# 'verbosity':1,
'arrayOrdering': 'RowMajor',
'seeds': [[0, 0]],
# 'solver':'AGSI',
# 'solver':'global_iteration',
'raiseOnNonConvergence': False,
'nitermax_o': 200,
'tol': 5 * 1e-7,
'multiprecision': True,
# 'values_float64':True,
'exportValues': True,
# 'help':['nitermax_o','traits'],
'dims': np.array((n, n)),
'origin': [-0.5, -0.5],
'gridScale': 1.,
# 'order':2,
# 'order2_threshold':0.3,
# 'factoringRadius':10000,
# 'seedRadius':2,
# 'returns':'in_raw',
'traits': {
'niter_i': 8,
'shape_i': (4, 4),
# 'niter_i':1,'shape_i':(8,8),
# 'niter_i':16,'shape_i':(8,8),
# 'niter_i':32,'shape_i':(16,16),
# 'niter_i':48,'shape_i':(24,24),
# 'niter_i':64,'shape_i':(32,32),
# 'debug_print':1,
# 'niter_i':1,
'strict_iter_i_macro': 1,
'pruning_macro': 0,
'strict_iter_o_macro': 1,
},
# 'nonzero_untidy_kwargs':{'log2_size_i':8,'size2_i':256},
})
cp = ad.functional.decorate_module_functions(
cp, cugen.set_output_dtype32
) # Use float32 and int32 types in place of float64 and int64
plt = ad.functional.decorate_module_functions(plt, cugen.cupy_get_args)
HFMUtils.dictIn.RunSmart = cugen.cupy_get_args(HFMUtils.RunSmart,
dtype64=True,
iterables=(dict, Metrics.Base))
n = 7
hfmIn = HFMUtils.dictIn({
'model': 'Isotropic2',
'seeds': [[0., 0.]],
'exportValues': 1,
'cost': cp.array(1.),
'exportGeodesicFlow': 1,
'traits': {
'debug_print': 1,
'shape_i': (8, 8),
'niter_i': 16,
},
})
hfmIn.SetRect([[0, 1], [0, 1]], dimx=n + 1, sampleBoundary=True)
X = hfmIn.Grid()
hfmIn['tips'] = hfmIn.Grid(dims=(4, 4)).reshape(2, -1).T
walls = X[0] >= 0.5
hfmIn['walls'] = walls
hfmOut = hfmIn.RunGPU()
print(hfmOut['values'])
print(walls)
def _solve_pde(self, image=None, vesselness=None, vesselMask=None):
# TODO: Improve and validate seed-point selection
# <axis>_seed_point -- traveses through slices in a direction perpendicular to the axis to find seed-point
eff_vesselMask = vesselMask[:, :, :-10]
if self.seed_point is None:
z_seed_point = self._find_seed_point(vesselMask=eff_vesselMask,
binarize=False)
print('Seed-point perpendicular to Z-axis = {}. {}, {}'.format(
z_seed_point[1], z_seed_point[0], z_seed_point[2]))
# Exchange X and Z axes of vessel mask
x_seed_point = self._find_seed_point(
vesselMask=eff_vesselMask.transpose((0, 2, 1)), binarize=False)
# Swap it back to the right order
x_seed_point_swapped = np.array(
[x_seed_point[0], x_seed_point[2], x_seed_point[1]])
print('Seed-point perpendicular to X-axis = {}, {}, {}'.format(
x_seed_point_swapped[1], x_seed_point_swapped[0],
x_seed_point_swapped[2]))
# Exchange Y and Z axes of vessel mask
y_seed_point = self._find_seed_point(
vesselMask=eff_vesselMask.transpose((2, 1, 0)), binarize=False)
# Swap it back to the right order
y_seed_point_swapped = np.array(
[y_seed_point[2], y_seed_point[1], y_seed_point[0]])
print('Seed-point perpendicular to the Y-axis = {}, {}, {}'.format(
y_seed_point_swapped[1], y_seed_point_swapped[0],
y_seed_point_swapped[2]))
seed_pts = np.array(
[z_seed_point, x_seed_point_swapped, y_seed_point_swapped])
else:
print('User-defined seed-point at {}, {}, {}'.format(
self.seed_point[1], self.seed_point[0], self.seed_point[2]))
seed_pts = np.array(
[[self.seed_point[1], self.seed_point[0], self.seed_point[2]]])
if self.verbose is True:
verbosity = 2
showProgress = 1
else:
verbosity = 0
showProgress = 0
if self.model.lower() == 'isotropic':
speed_function = 1 + self.lmbda * np.power(image, self.p)
params = {
'model': 'Isotropic3',
'arrayOrdering': 'YXZ_RowMajor',
'order': 2,
'dims': [image.shape[0], image.shape[1], image.shape[2]],
# size of a pixel (only for physical dimensions)
'gridScale': 1.,
'speed': speed_function,
'seeds': seed_pts,
'exportValues': self.get_distance_map,
'exportGeodesicFlow': 1,
'verbosity': verbosity,
'showProgress': showProgress
}
else: # self.model = 'riemann'
if vesselness is None:
raise RuntimeError(
'Riemannian metric tensor needs vesselness function to compute eigenvalues'
)
metric_tensor = self.create_riemannian_metric_tensor(
hessian=image, vesselness=vesselness)
params = {
'model': 'Riemann3',
'arrayOrdering': 'YXZ_RowMajor',
'order': 2,
'dims': [image.shape[0], image.shape[1], image.shape[2]],
# size of a pixel (only for physical dimensions)
'gridScale': 1.,
'metric': metric_tensor,
'seeds': seed_pts,
'exportValues': 1,
'verbosity': verbosity,
'showProgress': showProgress
}
self.output = HFMUtils.Run(params)
return seed_pts
import cupy as cp
import numpy as np
import time
from agd.AutomaticDifferentiation.Optimization import norm_infinity
from agd import AutomaticDifferentiation as ad
np.set_printoptions(edgeitems=30,
linewidth=100000,
formatter=dict(float=lambda x: "%5.3g" % x))
#n=20; nTheta=60
n = 100
nTheta = 96
hfmIn = HFMUtils.dictIn({
'model': 'Elastica2',
'seeds': cp.array([[0., 0., np.pi]], dtype=np.float32),
'exportValues': 1,
'cost': 1,
'xi': 0.4,
# 'nitermax_o':1,
'traits': {
'OffsetT': np.int32,
'merge_sort_macro': 1
}
})
hfmIn.SetRect([[-1, 1], [-1, 1]], dimx=n + 1, sampleBoundary=True)
hfmIn['dims'] = np.append(hfmIn['dims'], nTheta)
hfmOut = hfmIn.RunGPU()
#print(hfmOut['scheme_offsets'][0])