def applyKernelMA(inputImage, kernelX, kernelY, normalizeMagnitude=False):
height = len(inputImage)
width = len(inputImage[0])
kernelHeight = len(kernelX)
kerelWidth = len(kernelX[0])
kernelCentreY = int((kernelHeight - 1) / 2)
kernelCentreX = int((kerelWidth - 1) / 2)
# Create images to store the result
magnitude = createImageF(width, height)
direction = createImageF(width, height)
imageX = createImageF(width, height)
imageY = createImageF(width, height)
# Convolution with two kernels
for x,y in itertools.product(range(kernelCentreX, width - kernelCentreX), \
range(kernelCentreY, height - kernelCentreY)):
sumKernel = [0.0, 0.0]
sumKernelWeights = [0.0, 0.0]
for wx, wy in itertools.product(range(0, kerelWidth),
range(0, kernelHeight)):
posY = y + wy - kernelCentreY
posX = x + wx - kernelCentreX
if posY > -1 and posY < height and posX > -1 and posX < width:
sumKernel[0] += float(inputImage[posY, posX]) * float(
kernelX[wy, wx])
sumKernelWeights[0] += float(kernelX[wy, wx])
sumKernel[1] += float(inputImage[posY, posX]) * float(
kernelY[wy, wx])
sumKernelWeights[1] += float(kernelY[wy, wx])
# If we have to normalize
if sumKernelWeights[0] != 0.0:
imageX[y, x] = sumKernel[0] / sumKernelWeights[0]
else:
imageX[y, x] = sumKernel[0]
# If we have to normalize
if sumKernelWeights[1] != 0.0:
imageY[y, x] = sumKernel[1] / sumKernelWeights[1]
else:
imageY[y, x] = sumKernel[1]
magnitude[y, x] = sqrt(imageX[y, x] * imageX[y, x] +
imageY[y, x] * imageY[y, x])
direction[y, x] = atan2(imageY[y, x], imageX[y, x])
if normalizeMagnitude == True:
maximum, minimum = imageMaxMin(magnitude)
for x, y in itertools.product(range(0, width), range(0, height)):
magnitude[y, x] = (magnitude[y, x] - minimum) / float(maximum -
minimum)
return magnitude, direction, imageX, imageY
def regionSize(backProjImage, newBackProjImage, pos, newPos, sizeReg):
# Compute geometric moments
momS = createImageF(3, 3)
momT = createImageF(3, 3)
sizeSearch = [int(sizeReg[0] * 1.5), int(sizeReg[1] * 1.5)]
for deltaX, deltaY in itertools.product(range(-sizeSearch[0], sizeSearch[0]), \
range(-sizeSearch[1], sizeSearch[1])):
x, y = pos[0] + deltaX, pos[1] + deltaY
for m, n in itertools.product(range(0, 3), range(0, 3)):
momS[n, m] += (x**n) * (y**m) * backProjImage[y, x]
x, y = newPos[0] + deltaX, newPos[1] + deltaY
for m, n in itertools.product(range(0, 3), range(0, 3)):
momT[n, m] += (x**n) * (y**m) * newBackProjImage[y, x]
xc, yc = momS[1, 0] / momS[0, 0], momS[0, 1] / momS[0, 0]
a = momS[2, 0] / momS[0, 0] - xc * xc
b = 2 * (momS[1, 1] / momS[0, 0] - xc * yc)
c = momS[0, 2] / momS[0, 0] - yc * yc
sxS = int(sqrt((a + c - sqrt(b * b + (a - c) * (a - c)) / 2)))
syS = int(sqrt((a + c + sqrt(b * b + (a - c) * (a - c)) / 2)))
xc, yc = momT[1, 0] / momT[0, 0], momT[0, 1] / momT[0, 0]
a = momT[2, 0] / momT[0, 0] - xc * xc
b = 2 * (momT[1, 1] / momT[0, 0] - xc * yc)
c = momT[0, 2] / momT[0, 0] - yc * yc
sx = int(sqrt((a + c - sqrt(b * b + (a - c) * (a - c)) / 2)))
sy = int(sqrt((a + c + sqrt(b * b + (a - c) * (a - c)) / 2)))
sy = sy * sizeReg[1] / syS
sx = sx * sizeReg[0] / sxS
return [int(xc), int(yc)], [int(sx), int(sy)]
def createLaplacianKernel(kernelSize, sigma):
# kernel
kernelLaplacian = createImageF(kernelSize, kernelSize)
# Create kernel
s2Inv = 1.0 / (sigma * sigma)
kernelCentre = (kernelSize - 1) / 2
# Generate kernel values
sumValues = 0.0
for x, y in itertools.product(range(0, kernelSize), range(0, kernelSize)):
nx2 = float(x - kernelCentre) * float(x - kernelCentre)
ny2 = float(y - kernelCentre) * float(y - kernelCentre)
s = 0.5 * (nx2 + ny2) * s2Inv
kernelLaplacian[y, x] = -s2Inv * s2Inv * (1.0 - s) * exp(-s)
sumValues += kernelLaplacian[y, x]
# Normalize
for x, y in itertools.product(range(0, kernelSize), range(0, kernelSize)):
kernelLaplacian[y, x] /= sumValues
return kernelLaplacian
def fillImageColours(colours, xy, image):
nfaces = len(xy)
height = len(image)
width = len(image[0])
for faceNum in range(0, nfaces):
face = xy[faceNum]
npts = len(face)
colour = colours[faceNum]
for a,b in itertools.product(range(0, npts-1), range(0, npts-1)):
c0,c1,c2 = face[a][b], face[a+1][b], face[a][b+1]
c = colour[a,b];
# Fill output image
v1 = [c1[0]-c0[0], c1[1]-c0[1]]
v2 = [c2[0]-c0[0], c2[1]-c0[1]]
lv1 = max(.001,sqrt(v1[0]*v1[0] + v1[1]*v1[1]))
lv2 = max(.001,sqrt(v2[0]*v2[0] + v2[1]*v2[1]))
v1N = [v1[0]/lv1, v1[1]/lv1]
v2N = [v2[0]/lv2, v2[1]/lv2]
for dV1, dV2 in itertools.product(range(0, 4*(1+int(lv1))), range(0, 4*(1+int(lv2)))):
x = int(c0[0] + v2N[0] * dV2*.25 + v1N[0] * dV1*.25)
y = int(c0[1] + v2N[1] * dV2*.25 + v1N[1] * dV1*.25)
if x>0 and x < width and y > 0 and y < height:
image[y,x] = c
def applyKernelF(inputImage, kernelImage):
height = len(inputImage)
width = len(inputImage[0])
kernelHeight = len(kernelImage)
kernelWidth = len(kernelImage[0])
kernelCentreY = int((kernelHeight - 1) / 2)
kernelCentreX = int((kernelWidth - 1) / 2)
# Create images to store the result
outputImage = createImageF(width, height)
for x, y in itertools.product(range(0, width), range(0, height)):
sumKernel = 0.0
sumKernelWeights = 0.0
for wx, wy in itertools.product(range(0, kernelWidth),
range(0, kernelHeight)):
posY = y + wy - kernelCentreY
posX = x + wx - kernelCentreX
if posY > -1 and posY < height and posX > -1 and posX < width:
sumKernel += float(inputImage[posY, posX]) * float(
kernelImage[wy, wx])
sumKernelWeights += float(kernelImage[wy, wx])
# If we have to normalize
if sumKernelWeights != 0.0:
outputImage[y, x] = sumKernel / sumKernelWeights
else:
outputImage[y, x] = sumKernel
return outputImage
def densityHistogram(image, position, regionRadius, sigma, histoSize):
height = len(image)
width = len(image[0])
# Quantization scale
colourScale = 256.0 / histoSize
histogram = createImageF(histoSize, histoSize)
sumValue = 0
for deltaX, deltaY in itertools.product(
range(-regionRadius[0], regionRadius[0]),
range(-regionRadius[1], regionRadius[1])):
x, y = position[0] + deltaX, position[1] + deltaY
if x > 0 and y > 0 and x < width and y < height:
w = exp(-(deltaX * deltaX + deltaY * deltaY) / (2 * sigma * sigma))
rgb = image[y, x] / 256.0
Cb = int((128 - 37.79 * rgb[0] - 74.203 * rgb[1] + 112 * rgb[2]) /
colourScale)
Cr = int((128 + 112 * rgb[0] - 93.786 * rgb[1] - 18.214 * rgb[2]) /
colourScale)
histogram[Cr, Cb] += w
sumValue += w
for r, b in itertools.product(range(0, histoSize), range(0, histoSize)):
histogram[r, b] /= sumValue
return histogram
def getMoveCombinationAll(self,player,state):
posL=[]
lD=[]
for (r,c,p) in self.getAnts(state,player):
locc,dir=self.storeMovePosition.getMove((r,c))
posL.append(locc)
lD.append(dir)
return (list(itertools.product(*posL)),list(itertools.product(*lD)))
def meanShift(inputImage, q, sizeReg, sigma, histoSize, newPos):
# Weights
weights = createImageF(2 * sizeReg[0], 2 * sizeReg[1])
currPos = [0, 0]
colourScale = 256.0 / histoSize
while (currPos != newPos):
currPos = newPos
qs = densityHistogram(inputImage, currPos, sizeReg, sigma, histoSize)
# Weights
for deltaX, deltaY in itertools.product(range(-sizeReg[0],sizeReg[0]), \
range(-sizeReg[1], sizeReg[1])):
# Position of the pixel in the image and in the weight array
x, y = currPos[0] + deltaX, currPos[1] + deltaY
px, py = deltaX + sizeReg[0], deltaY + sizeReg[1]
# Features
Cb, Cr = colourFeature(inputImage[y, x], colourScale)
# Update
if qs[Cr, Cb] > 0:
weights[py, px] = sqrt(q[Cr, Cb] / qs[Cr, Cb])
else:
weights[py, px] = sqrt(q[Cr, Cb] / .000000000001)
# Compute mean shift sums
meanSum = [0, 0]
kernelSum = 0
for deltaX, deltaY in itertools.product(range(-sizeReg[0],sizeReg[0]), \
range(-sizeReg[1], sizeReg[1])):
# Position of the pixel in the image
x, y = currPos[0] + deltaX, currPos[1] + deltaY
# Kernel parameter
w = exp(-(deltaX * deltaX + deltaY * deltaY) / (2 * sigma * sigma))
# Weight index
px, py = deltaX + sizeReg[0], deltaY + sizeReg[1]
# Mean sum
meanSum[0] += w * weights[py, px] * x
meanSum[1] += w * weights[py, px] * y
# Kernel sum
kernelSum += w * weights[py, px]
# Mean shift
newPos = [int(meanSum[0] / kernelSum), int(meanSum[1] / kernelSum)]
return newPos
def weightedKrawtchoukPolynomials(p, width):
# Data containers
sigma = createVectorF(width)
ro = createVectorF(width)
K = createImageF(width, width)
# Coefficient size
N = width - 1
# Weight
for x in range(0, width):
sigma[x] = nCr(N, x) * pow(p, x) * pow(1 - p, N - x)
# Scale factor. Commented direct computation and using for to avoid factorial
#for n in range(0,width):
# ro[n] = pow(-1,n) * pow((1-p)/p,n) * (float(factorial(n)) / risingFactorial(-N, n))
ro[0] = 1
for n in range(1, N):
ro[n] = (-1 * ((1.0 - p) / p) * n / (-N + (n - 1))) * ro[n - 1]
ro[N] = (((1.0 - p) / p) * N) * ro[N - 1]
# Krawtchouk matrix that store result of the polynomial
# Each row is a polynomial each column is the polynomial value for an x value
# Alternatively, we could have used the polynomial generating function
q = 1.0 / p
for n, x in itertools.product(range(0, width), range(0, width)):
for s in range(0, width):
K[n, x] += pow(-1, s) * nCr(N - x, n - s) * nCr(x, s) * pow(
q - 1, n - s)
# Normalize rows for stability
for n in range(0, width):
scale = K[n, 0]
for x in range(0, width):
K[n, x] /= scale
# Obtain the coefficients A of the polynomials from K
# Solve for the coefficients A in A*C = K
C = createImageF(width, width)
for n, x in itertools.product(range(0, width), range(0, width)):
C[n, x] = pow(x, n)
CT = np.transpose(C)
KT = np.transpose(K)
AT = np.linalg.solve(CT,
KT) # solves the equation A*x=b A*C = k, C'*A' = K'
A = np.transpose(AT)
# Product defining the weighted
w = createImageF(width, width)
for n, x in itertools.product(range(0, width), range(0, width)):
w[n, x] = sqrt(sigma[x] / ro[n])
return K, A, sigma, ro, w
def backProjection(sourceImage, targetImage, qSource, pSource, pTarget,
sizeReg, histoSize):
height, width = len(sourceImage), len(sourceImage[0])
colourScale = 256.0 / histoSize
# Projection
projectionSource = createImageF(width, height)
projectionTarget = createImageF(width, height)
for x, y in itertools.product(range(0, width), range(0, height)):
Cb, Cr = colourFeature(sourceImage[y, x], colourScale)
projectionSource[y, x] = qSource[Cr, Cb]
Cb, Cr = colourFeature(targetImage[y, x], colourScale)
projectionTarget[y, x] = qSource[Cr, Cb]
# Compute geometric moments
momS = createImageF(3, 3)
momT = createImageF(3, 3)
sizeSearch = [int(sizeReg[0] * 1.5), int(sizeReg[1] * 1.5)]
for deltaX, deltaY in itertools.product(range(-sizeSearch[0], sizeSearch[0]), \
range(-sizeSearch[1], sizeSearch[1])):
x, y = pSource[0] + deltaX, pSource[1] + deltaY
for m, n in itertools.product(range(0, 3), range(0, 3)):
momS[n, m] += (x**n) * (y**m) * projectionSource[y, x]
x, y = pTarget[0] + deltaX, pTarget[1] + deltaY
for m, n in itertools.product(range(0, 3), range(0, 3)):
momT[n, m] += (x**n) * (y**m) * projectionTarget[y, x]
xc, yc = momS[1, 0] / momS[0, 0], momS[0, 1] / momS[0, 0]
a = momS[2, 0] / momS[0, 0] - xc * xc
b = 2 * (momS[1, 1] / momS[0, 0] - xc * yc)
c = momS[0, 2] / momS[0, 0] - yc * yc
sxS = int(sqrt((a + c - sqrt(b * b + (a - c) * (a - c)) / 2)))
syS = int(sqrt((a + c + sqrt(b * b + (a - c) * (a - c)) / 2)))
xc, yc = momT[1, 0] / momT[0, 0], momT[0, 1] / momT[0, 0]
a = momT[2, 0] / momT[0, 0] - xc * xc
b = 2 * (momT[1, 1] / momT[0, 0] - xc * yc)
c = momT[0, 2] / momT[0, 0] - yc * yc
sx = int(sqrt((a + c - sqrt(b * b + (a - c) * (a - c)) / 2)))
sy = int(sqrt((a + c + sqrt(b * b + (a - c) * (a - c)) / 2)))
sy = sy * sizeReg[1] / syS
sx = sx * sizeReg[0] / sxS
return [int(xc), int(yc)], [int(sx), int(sy)]
def csv_format(initial_matrix):
global nodes
global temp_nodes
new_list = []
zero_list = []
dir_values = ['fw', 'bw']
g_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
f_values = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32
]
#print("h")
for node in temp_nodes:
#print("hi")
if (node.getstate() == 'closed'):
hdir = node.gethvalue()
#print(hdir)
fdir = node.getvalue() + hdir
new_list.append((node.getdirection(), node.getvalue(), fdir))
prod_list = list(itertools.product(dir_values, g_values, f_values))
#zero_list = set(new_list).intersection(set(prod_list))
for i in prod_list:
if i not in new_list:
zero_list.append(i)
#print(zero_list)
return new_list, zero_list
def plot_peaks(self,
qz_lims=[-1e-5, 1],
q_para_lim=6,
qx_lims=None,
qy_lims=None,
HKL_lims=[-10, 10],
color=(0, 0, 0)):
HKLs = list(
itertools.product(np.arange(HKL_lims[0], HKL_lims[1]), repeat=3))
qs = []
Is = []
for HKL in HKLs:
q = self.lattice.q(HKL)
if (q_para_lim != None):
if (q[2] >= qz_lims[0] and q[2] < qz_lims[1]
and np.sqrt(q[0]**2 + q[1]**2) <= q_para_lim):
qs.append(q)
Is.append(self.lattice.I(HKL))
elif (qx_lims != None and qy_lims != None):
if (q[0] >= qx_lims[0] and q[0] < qx_lims[1]
and q[1] >= qy_lims[0] and q[1] < qy_lims[1]
and q[2] >= qz_lims[0] and q[2] < qz_lims[1]):
qs.append(q)
Is.append(self.lattice.I(HKL))
qs = np.array(qs)
qs = np.swapaxes(qs, 0, 1)
Is = np.array(Is)
Is /= np.max(Is)
mlab.points3d(qs[0], qs[1], qs[2], Is, scale_factor=1, color=color)
def get_rod_positions(self, qz_lims=[-1e-5,1], q_para_lim=6, qx_lims=None, qy_lims=None, HKL_lims=[-10, 10], color=(0,0,0)):
HKLs = list(itertools.product(np.arange(HKL_lims[0],HKL_lims[1]), repeat=3))
qIs = []
for HKL in HKLs:
qI = self.lattice.qI(HKL)
if(q_para_lim != None):
if(qI[2] >= qz_lims[0] and qI[2] < qz_lims[1] and np.sqrt(qI[0]**2+qI[1]**2)<= q_para_lim):
qIs.append(qI)
elif(qx_lims != None and qy_lims != None):
if(qI[0] >= qx_lims[0] and qI[0] < qx_lims[1] and qI[1] >= qy_lims[0] and qI[1] < qy_lims[1] and qI[2] >= qz_lims[0] and qI[2] < qz_lims[1]):
qIs.append(qI)
qIs = np.array(qIs)
rows = np.where(qIs[:,3] > 1e-20)
qIs = qIs[rows]
qIs_filtered = []
for qI in qIs:
add_qI = True
for qI_filtered in qIs_filtered:
if((abs(qI[0]-qI_filtered[0]) < 0.001) and (abs(qI[1]-qI_filtered[1]) < 0.001)):
add_qI = False
break
if(add_qI):
qIs_filtered.append(qI)
return qIs_filtered
def three_parents(self, utility_node, e, known, known_set):
result = self.two_generate(e, utility_node)
table = list(itertools.product([True, False], repeat=2 - len(known)))
total = 0.0
if len(known) == 0:
for tuple in range(len(table)):
tuple_set = table[tuple]
total += result[tuple_set]
return total
if len(known) == 1:
for tuple in range(len(table)):
(i, j) = table[tuple]
if known_set[0] == True:
total += result[(known[0], i, j)]
if known_set[1] == True:
total += result[(i, known[0], j)]
else:
total += result[(i, j, known[0])]
if len(known) == 2:
for tuple in range(len(table)):
(i, ) = table[tuple]
if known_set[0] == True and known_set[1] == True:
total += result[(known[0], known[1], i)]
if known_set[0] == True and known_set[2] == True:
total += result[(known[0], i, known[1])]
if known_set[1] == True and known_set[2] == True:
total += result[(i, known[0], known[1])]
else:
total += result[(known[0], known[1], known[2])]
return total
def plot_peaks(self,
HKL_lims=[-10, 10],
qx_lims=None,
qy_lims=None,
q_inplane_lim=None,
qz_lims=None,
mag_q_lims=None,
color=(0, 0, 0),
scale_factor=1):
HKL_range = np.arange(HKL_lims[0], HKL_lims[1] + 1)
HKLs = list(itertools.product(HKL_range, repeat=3))
qs = []
Is = []
for HKL in HKLs:
q = self.lattice.q(HKL)
if (self.is_in_limits(q, qx_lims, qy_lims, q_inplane_lim, qz_lims,
mag_q_lims)):
qs.append(q)
Is.append(self.lattice.I(HKL))
qs = np.array(qs)
qs = np.swapaxes(qs, 0, 1)
Is = np.array(Is)
if (len(Is > 0)):
# Normalize to (0,0,0) intensity and plot the sqrt
Is /= self.lattice.I([0, 0, 0])
Is = np.sqrt(Is)
mlab.points3d(qs[0],
qs[1],
qs[2],
Is,
scale_factor=scale_factor,
color=color)
def get_rod_positions(self,
HKL_lims=[-10, 10],
qx_lims=None,
qy_lims=None,
q_inplane_lim=None,
qz_lims=None,
color=(0, 0, 0)):
HKL_range = np.arange(HKL_lims[0], HKL_lims[1] + 1)
HKLs = list(itertools.product(HKL_range, repeat=3))
qIs = []
# Find all lattice positions within limits
for HKL in HKLs:
q = self.lattice.q(HKL)
if (self.is_in_limits(q, qx_lims, qy_lims, q_inplane_lim,
qz_lims)):
qIs.append(self.lattice.qI(HKL))
# Select all positions with non-zero intensity
qIs = np.array(qIs)
rows = np.where(qIs[:, 3] > 1e-20)
qIs = qIs[rows]
# We only need one point per (qx, qy) coordinate
qIs_filtered = []
for qI in qIs:
add_qI = True
for qI_filtered in qIs_filtered:
if ((abs(qI[0] - qI_filtered[0]) < 0.001)
and (abs(qI[1] - qI_filtered[1]) < 0.001)):
add_qI = False
break
if (add_qI):
qIs_filtered.append(qI)
return qIs_filtered
def reconstruction(coefficients):
# Maximum frequency
maxFrequencyH = int((len(coefficients) - 1) / 2)
maxFrequencyW = int((len(coefficients[0]) - 1) / 2)
height = 2 * maxFrequencyH
width = 2 * maxFrequencyW
# Adjust the size of the data to be even
m = float(width)
n = float(height)
if width % 2 == 0:
m = width + 1
if height % 2 == 0:
n = height + 1
# Fundamental frequency
ww = (2.0 * pi) / float(m)
wh = (2.0 * pi) / float(n)
reconstructionImage = createImageF(m, n)
for x in range(0, width):
printProgress(x, width - 1)
for y in range(0, height):
for kw,kh in itertools.product(range(-maxFrequencyW, maxFrequencyW + 1), \
range(-maxFrequencyH, maxFrequencyH + 1)):
indexInArrayW = kw + maxFrequencyW
indexInArrayH = kh + maxFrequencyH
reconstructionImage[y,x] += \
(coefficients[indexInArrayH, indexInArrayW][0] / (m*n)) * (cos(x * ww * kw) * cos(y * wh * kh) - sin(x * ww * kw) * sin(y * wh * kh)) + \
(coefficients[indexInArrayH, indexInArrayW][1] / (m*n)) * (cos(x * ww * kw) * sin(y * wh * kh) + sin(x * ww * kw) * cos(y * wh * kh))
return reconstructionImage
def findPureNash(self):
nash = []
bestAnswers = []
# print self.strategy_profiles
for players in range(0, len(self.player_names)):
strategiesOfOtherPlayers = []
for strategie in range(0, len(self.strategies)):
if strategie != players:
strategiesOfOtherPlayers.append(self.strategies[strategie])
currentPlayersBestAnswers = []
for othersStrategies in list(itertools.product(*strategiesOfOtherPlayers)):
currentBestAnswers = []
bestPayoff = -sys.maxint - 1
for strategyOfCurrentPlayer in self.strategies[players]:
currentProfile = []
currentProfile += othersStrategies
currentProfile.insert(players, strategyOfCurrentPlayer)
# print currentProfile
indexInAllProfiles = list(self.strategy_profiles).index(currentProfile)
currentPayoff = self.payoffs[self.outcomes[indexInAllProfiles]][players + 1]
if currentPayoff > bestPayoff:
currentBestAnswers = [tuple(currentProfile)]
bestPayoff = currentPayoff
elif currentPayoff == bestPayoff:
currentBestAnswers.append(tuple(currentProfile))
# print "player " + str(players) + ": best answer for " + str(othersStrategies) + " is " + str(bestAnswers)
# bestAnswers.append(tuple(currentBestAnswers))
currentPlayersBestAnswers += currentBestAnswers
bestAnswers.append(currentPlayersBestAnswers)
nash = set(tuple(bestAnswers[0]))
for players in range(len(self.player_names)):
nash = nash & set(tuple(bestAnswers[players]))
return nash
def powder(self, q_max, HKL_lims=[-10, 10]):
HKL_range = np.arange(HKL_lims[0], HKL_lims[1] + 1)
HKLs = list(itertools.product(HKL_range, repeat=3))
qIs = []
Is = dict()
# Find all lattice positions within limits
for HKL in HKLs:
q = self.q(HKL)
Q = np.sqrt(q.dot(q))
if (Q <= q_max):
if Q in Is:
Is[Q] += self.I(HKL)
else:
Is[Q] = self.I(HKL)
Q = []
I = []
for key in Is:
Q.append(key)
I.append(Is[key])
indices = np.argsort(Q)
Q_sorted = []
I_sorted = []
for index in indices:
Q_sorted.append(Q[index])
I_sorted.append(I[index])
Q_sorted = np.array(Q_sorted)
I_sorted = np.array(I_sorted) / I_sorted[0]
return (Q_sorted, I_sorted)
def pixlesList(image, backgroundRange):
listPixels = []
height, width = len(image), len(image[0])
for x, y in itertools.product(range(0, width), range(0, height)):
if image[y, x] < backgroundRange[0] or image[y,
x] > backgroundRange[1]:
listPixels.append((y, x, 1))
return listPixels
def __init__(self, name, go, perf_p=[], perf_cc=[], perf_pp=[]):
self.name = name
self.go = go
if os.path.exists(BENCHMARKS_DIRECTORY + os.sep + name):
if perf_p or perf_cc or perf_pp:
raise Exception(
'Benchmark "' + name +
'" already exists, you can\'t specify performance options')
with open(BENCHMARKS_DIRECTORY + os.sep + name, 'rb') as f:
bm = pickle.load(f)
self.perf_p = bm.perf_p
self.perf_cc = bm.perf_cc
self.perf_pp = bm.perf_pp
self.items = bm.items
self.series = bm.series
return
else:
if not perf_p and not perf_cc and not perf_pp:
raise Exception(
'Benchmark "' + name +
'" does not exist, you need to specify performance options (e.g. --perf-p=1,8,16 --perf-cc=1 --perf-pp=1,16,32)'
)
if perf_p:
self.perf_p = perf_p
else:
self.perf_p = [1]
if perf_cc:
self.perf_cc = perf_cc
else:
self.perf_cc = [1]
if perf_pp:
self.perf_pp = perf_pp
else:
self.perf_pp = [1]
self.items = []
self.series = []
# first, we always run the "no-option" globus default, to have a comparison
self.items.append(BenchmarkItem(0, 0, 0))
combinantions = itertools.product(self.perf_p, self.perf_cc,
self.perf_pp)
for c in combinantions:
item = BenchmarkItem(c[0], c[1], c[2])
self.items.append(item)
self.save()
def imageTransform(image, maskImage, T):
height, width = len(image), len(image[0])
centreX, centreY = width/2, height/2
sImage = createImageRGB(width, height)
for y, x in itertools.product(range(0, height-1), range(0, width-1)):
# Alpha and colour
alpha = maskImage[y,x]/256.0
if alpha == 0:
continue
rgb = (image[y,x]/4.0 + image[y+1,x+1]/4.0 + image[y+1,x]/4.0 + \
image[y,x+1]/4.0) * alpha
# Transform
cx, cy = x - centreX, y - centreY
p0z = T[2][0] * cx + T[2][1] * cy + T[2][2]
p1z = T[2][0] * (cx+1) + T[2][1] * cy + T[2][2]
p2z = T[2][0] * (cx+1) + T[2][1] * (cy+1) + T[2][2]
if p0z != 0 and p1z != 0 and p2z !=0:
p0x = int((T[0][0] * cx + T[0][1] * cy + T[0][2]) / p0z + centreX)
p0y = int((T[1][0] * cx + T[1][1] * cy + T[1][2]) / p0z + centreY)
p1x = int((T[0][0] * (cx+1) + T[0][1] * cy + T[0][2]) / p1z + centreX)
p1y = int((T[1][0] * (cx+1) + T[1][1] * cy + T[1][2]) / p1z + centreY)
p2x = int((T[0][0] * (cx+1) + T[0][1] * (cy+1) + T[0][2]) / p2z + centreX)
p2y = int((T[1][0] * (cx+1) + T[1][1] * (cy+1) + T[1][2]) / p2z + centreY)
# Fill output image
v1, v2 = [p1x - p0x, p1y - p0y], [p2x - p0x, p2y - p0y]
lv1 = max(.001,sqrt(v1[0]*v1[0] + v1[1]*v1[1]))
lv2 = max(.001,sqrt(v2[0]*v2[0] + v2[1]*v2[1]))
v1N = [v1[0]/lv1, v1[1]/lv1]
v2N = [v2[0]/lv2, v2[1]/lv2]
for dV1, dV2 in itertools.product(range(0, int(lv1)+1), range(0, int(lv2)+1)):
a,b = int(p0x + dV1 * v1N[0] + dV2 * v2N[0]), int(p0y + dV1 * v1N[1] + dV2 * v2N[1])
if a>0 and a < width and b > 0 and b < height:
sImage[b,a] = rgb
return sImage
def createGaussianKernel(kernelSize):
sigma = kernelSize / 3.0
kernelImage = createImageF(kernelSize, kernelSize)
centre = (kernelSize - 1) / 2
for x, y in itertools.product(range(0, kernelSize), range(0, kernelSize)):
kernelImage[y,x] = exp( -0.5 * (pow((x - centre)/sigma, 2.0) + \
pow((y - centre)/sigma, 2.0)) )
return kernelImage
def backProjectionImage(image, q, histoSize):
height, width = len(image), len(image[0])
colourScale = 256.0 / histoSize
# Projection
projection = createImageF(width, height)
for x, y in itertools.product(range(0, width), range(0, height)):
Cb, Cr = colourFeature(image[y, x], colourScale)
projection[y, x] = q[Cr, Cb]
return projection
def compareBasicAlphas(resimulate=True,
Tf = 2.,
tau_chars = [.5,2],
mus = [-1,1]):
sigma = 1.;
params = array([sigma]);
amax = 1.0
alpha_bounds = [-amax, amax];
dt = .01; num_nodes = 200;
lSolver = FBSolver(dt, Tf, num_nodes, xmin=-5., xmax=5.)
thetas = list( itertools.product(mus, tau_chars))
pThetas = ones(len (thetas)) / len(thetas);
'ALPHAS::'
alpha_bang_bang = lambda x: amax* sign(x)
alpha_null = lambda x: .0*x
alpha_antibang = lambda x: -sign(x)* amax
alpha_H1 = lambda x: amax* sign(x)*(abs(x) > 1.)
# alpha_tags = ['bang_bang', 'atan_bang_bang', 'null', 'atan_bang_bang']
# alpha_funcs = [alpha_bang_bang, alpha_atan, alpha_null, alpha_antiatan]
alpha_tags = ['bang_bang', 'anti_bang', 'alpha_null', 'alpha_H1']
alpha_funcs = [alpha_bang_bang, alpha_antibang, alpha_null, alpha_H1]
alpha_fig = figure()
for alpha_func, alpha_tag in zip(alpha_funcs,
alpha_tags):
fb_file_name = 'alpha_'+ alpha_tag;
if resimulate:
alphas = lSolver.generateAlphaField(alpha_func);
xs = lSolver._xs;
width = 2.0; x_0 = .0;
pre_ICs = exp(-(xs-x_0)**2 / width**2) / (width * sqrt(pi))
ICs = pre_ICs / (sum(pre_ICs)*lSolver._dx)
xs, ts, fs, ps, J, grad_J = lSolver.solve(thetas, pThetas,
params, alphas,
ICs,
visualize=False)
(FBSolution(params, thetas, pThetas, xs, ts,
fs, ps, alphas, grad_J, J)).save(fb_file_name)
fbSoln = FBSolution.load(fb_file_name)
xs = lSolver._xs;
ax = alpha_fig.add_subplot(111)
ax.plot(xs, alpha_func(xs), label=alpha_tag)
ax.set_ylim((-amax-1,+amax+1))
ax.legend()
print alpha_tag + 'J=%.3g'%lSolver._calcObjective(fbSoln._fs, fbSoln._pThetas)
def computeHistogram(inputImage):
height = len(inputImage)
width = len(inputImage[0])
# Vector of integers values to store the number of times a pixel value is repeated
outputHistogram = createVectorI(256)
# Get the number of times a pixel value is found in the image
for x, y in itertools.product(range(0, width), range(0, height)):
pixelValue = inputImage[y, x]
outputHistogram[pixelValue] += 1
return outputHistogram
def geometricInvariantMoments(pixelList, numMoments):
numPoints = len(pixelList)
# Compute moments
M = createImageF(numMoments, numMoments)
for m, n in itertools.product(range(0, numMoments), range(0, numMoments)):
for indexPixel in range(0, numPoints):
y = (pixelList[indexPixel])[0]
x = (pixelList[indexPixel])[1]
val = (pixelList[indexPixel])[2]
M[n, m] += (x**n) * (y**m) * val
# Geometric central Moments
xc, yc = M[1, 0] / M[0, 0], M[0, 1] / M[0, 0]
m11 = M[1, 1] / M[0, 0] - xc * yc
m20 = M[2, 0] / M[0, 0] - xc**2
m02 = M[0, 2] / M[0, 0] - yc**2
if m20 < m02:
t = -(0.5 * atan(2.0 * m11 / (m20 - m02)) + pi / 2.0)
else:
t = -(0.5 * atan(2.0 * m11 / (m20 - m02)))
# Geometric invariant moments
v = createImageF(numMoments, numMoments)
vn = createImageF(numMoments, numMoments)
for m, n in itertools.product(range(0, numMoments), range(0, numMoments)):
for indexPixel in range(0, numPoints):
y = (pixelList[indexPixel])[0]
x = (pixelList[indexPixel])[1]
val = (pixelList[indexPixel])[2]
v[n, m] += ((x - xc) * cos(t) -
(y - yc) * sin(t))**n * ((x - xc) * sin(t) +
(y - yc) * cos(t))**m * val
l = (1 + ((n + m) / 2.0))
vn[n, m] = v[n, m] / pow(M[0, 0], l)
return vn
def two_generate(self, e, utility_node):
varset = deepcopy(self.vars)
Q = {}
result = {}
table = list(itertools.product([True, False], repeat=2))
for tuple in range(len(table)):
(i, j) = table[tuple]
e[utility_node.parents[0]] = i
e[utility_node.parents[1]] = j
Q[tuple] = self.enumerate_all(varset, e)
result[table[tuple]] = Q[tuple] * float(
utility_node.cpt[table[tuple]])
return result
def geometricMoments(pixelList, numMoments):
numPoints = len(pixelList)
# Compute moments
M = createImageF(numMoments, numMoments)
for m, n in itertools.product(range(0, numMoments), range(0, numMoments)):
for indexPixel in range(0, numPoints):
y = (pixelList[indexPixel])[0]
x = (pixelList[indexPixel])[1]
val = (pixelList[indexPixel])[2]
M[n, m] += (x**n) * (y**m) * val
return M
def __init__(self, name, go, perf_p=[], perf_cc=[], perf_pp=[]):
self.name = name
self.go = go
if os.path.exists(BENCHMARKS_DIRECTORY+os.sep+name):
if perf_p or perf_cc or perf_pp:
raise Exception('Benchmark "'+name+'" already exists, you can\'t specify performance options')
with open(BENCHMARKS_DIRECTORY+os.sep+name, 'rb') as f:
bm = pickle.load(f)
self.perf_p = bm.perf_p
self.perf_cc = bm.perf_cc
self.perf_pp = bm.perf_pp
self.items = bm.items
self.series = bm.series
return
else:
if not perf_p and not perf_cc and not perf_pp:
raise Exception('Benchmark "'+name+'" does not exist, you need to specify performance options (e.g. --perf-p=1,8,16 --perf-cc=1 --perf-pp=1,16,32)')
if perf_p:
self.perf_p = perf_p
else:
self.perf_p = [1]
if perf_cc:
self.perf_cc = perf_cc
else:
self.perf_cc = [1]
if perf_pp:
self.perf_pp = perf_pp
else:
self.perf_pp = [1]
self.items = []
self.series = []
# first, we always run the "no-option" globus default, to have a comparison
self.items.append(BenchmarkItem(0,0,0))
combinantions = itertools.product(self.perf_p, self.perf_cc, self.perf_pp)
for c in combinantions:
item = BenchmarkItem(c[0], c[1], c[2])
self.items.append(item)
self.save()
def computeReferencePoint(edgeImage):
height, width = len(edgeImage), len(edgeImage[0])
refPoint = [0, 0]
edgePoints = []
for x, y in itertools.product(range(0, width), range(0, height)):
if edgeImage[y, x] != 0:
refPoint[0] += y
refPoint[1] += x
edgePoints.append((y, x))
numPts = len(edgePoints)
refPoint = [int(refPoint[0] / numPts), int(refPoint[1] / numPts)]
return refPoint, edgePoints
def __init__(self, game_title, player_names, strategies, payoffs, outcomes):
self.game_title = game_title
self.player_names = player_names
self.strategies = strategies
self.payoffs = payoffs
self.outcomes = outcomes
self.payoffs.insert(0, ["draw"] + ([0] * len(self.player_names)))
tmp = self.strategies
tmp.reverse()
strategy_profiles = list(itertools.product(*tmp))
self.strategy_profiles = []
for (x, y, i) in zip(strategy_profiles, self.outcomes, range(len(strategy_profiles))):
x = list(x)
x.reverse()
self.strategy_profiles.append(x)
def reducer(key, list_of_values):
# key: order_id
# value: list of tuples (table, attr)
recs = {}
for value in list_of_values:
table = value[0]
if not table in recs:
recs[table] = []
recs[table].append(value)
leftTable = recs.values()[0]
righTable = recs.values()[1]
for r in itertools.product(leftTable, righTable):
mr.emit(r[1] + r[0])
def edgesList(image, shapeImage, backgroundRange):
edgePixels = []
height, width = len(image), len(image[0])
numPoints = len(shapeImage)
for indexPixel in range(0, numPoints):
y, x = (shapeImage[indexPixel])[0], (shapeImage[indexPixel])[1]
edge = False
for wx, wy in itertools.product(range(-1, 2), range(-1, 2)):
posX, posY = x + wx, y + wy
if posY > -1 and posY < height and posX > -1 and posX < width:
if image[posY, posX] >= backgroundRange[0] and image[
posY, posX] <= backgroundRange[1]:
edge = True
if edge:
edgePixels.append((y, x))
return edgePixels
def createSobelKernel(kenrelSize):
sobelX = createImageF(kenrelSize, kenrelSize)
sobelY = createImageF(kenrelSize, kenrelSize)
# Create kernel
for x, y in itertools.product(range(0, kenrelSize), range(0, kenrelSize)):
# Smooth
smoothX = factorial(kenrelSize - 1) / (factorial(kenrelSize - 1 - x) *
factorial(x))
smoothY = factorial(kenrelSize - 1) / (factorial(kenrelSize - 1 - y) *
factorial(y))
# Pascal
if (kenrelSize - 2 - x >= 0):
p1X = factorial(kenrelSize - 2) / (factorial(kenrelSize - 2 - x) *
factorial(x))
else:
p1X = 0
if (kenrelSize - 2 - y >= 0):
p1Y = factorial(kenrelSize - 2) / (factorial(kenrelSize - 2 - y) *
factorial(y))
else:
p1Y = 0
# Pascal shift to the right
xp = x - 1
if (kenrelSize - 2 - xp >= 0 and xp >= 0):
p2X = factorial(kenrelSize - 2) / (factorial(kenrelSize - 2 - xp) *
factorial(xp))
else:
p2X = 0
yp = y - 1
if (kenrelSize - 2 - yp >= 0 and yp >= 0):
p2Y = factorial(kenrelSize - 2) / (factorial(kenrelSize - 2 - yp) *
factorial(yp))
else:
p2Y = 0
# Sobel
sobelX[y, x] = smoothX * (p1Y - p2Y)
sobelY[y, x] = smoothY * (p1X - p2X)
return sobelX, sobelY
def computeCoefficients(inputImage):
height = len(inputImage)
width = len(inputImage[0])
# Create coefficients Image. Two floats to represent a complex number
# Maximum frequency according to sampling
maxFrequencyW = int(width / 2)
maxFrequencyH = int(height / 2)
numCoefficientsW = 1 + 2 * maxFrequencyW
numCoefficientsH = 1 + 2 * maxFrequencyH
coefficients = createImageF(numCoefficientsW, numCoefficientsH, 2)
# Adjust the size of the data to be even
m = float(width)
n = float(height)
if width % 2 == 0:
m = width + 1
if height % 2 == 0:
n = height + 1
# Fundamental frequency
ww = (2.0 * pi) / float(m)
wh = (2.0 * pi) / float(n)
# Compute values
for kw in range(-maxFrequencyW, maxFrequencyW + 1):
printProgress(kw + maxFrequencyW, numCoefficientsW - 1)
for kh in range(-maxFrequencyH, maxFrequencyH + 1):
indexInArrayW = kw + maxFrequencyW
indexInArrayH = kh + maxFrequencyH
for x, y in itertools.product(range(0, width), range(0, height)):
coefficients[indexInArrayH,
indexInArrayW][0] += inputImage[y, x] * (
cos(x * ww * kw) * cos(y * wh * kh) -
sin(x * ww * kw) * sin(y * wh * kh))
coefficients[indexInArrayH,
indexInArrayW][1] += inputImage[y, x] * (
cos(x * ww * kw) * sin(y * wh * kh) +
sin(x * ww * kw) * cos(y * wh * kh))
for kw in range(-maxFrequencyW, maxFrequencyW + 1):
for kh in range(-maxFrequencyH, maxFrequencyH + 1):
coefficients[indexInArrayH, indexInArrayW][0] /= (m * n)
coefficients[indexInArrayH, indexInArrayW][1] /= (m * n)
return coefficients, maxFrequencyW, maxFrequencyH
def main(subjects):
import itertools
encoding = [["F", "L"], "F", "L"]
level = [["1","2","3"]]
masks_ = [["L_PPA_enc.nii", "L_HIPP_enc.nii"],
["L_PPA.nii", "L_FFA.nii"]]
conditions_dict = {
"encoding": ["F", "L"],
"response": ["C"],
"level": ["1"]
}
p = itertools.product(masks_, encoding, level)
for opt in p:
conditions_dict["encoding"] = opt[1]
conditions_dict["level"] = opt[2]
mask_name = opt[0]
print opt
analysis(subjects, seed_mask=mask_name, analysis="abs_difference", conditions=conditions_dict)
def expand(domain,problem,state):
ret = []
for (ac_name,action) in domain.actions.items():
parameters = action.params
applicable_list = []
for (p,t) in parameters:
objects = [po for po,to in problem.objects if to==t] + [po for po,to in domain.constants if to == t]
applicable_list.append(objects)
candidates = list(itertools.product(*applicable_list))
for candidate in candidates:
gpp = {ground(p,action.params,candidate) for p in action.pos_preq}
gnp = {ground(p,action.params,candidate) for p in action.neg_preq}
check_pos = gpp<=state
check_neg = len(gnp & state)==0
applicable = (check_pos and check_neg)
if applicable:
gpe = {ground(p,action.params,candidate) for p in action.pos_effects}
gne = {ground(p,action.params,candidate) for p in action.neg_effects}
n_state = (state | gpe )-gne
ret.append((ac_name,candidate,n_state))
return ret
def readIn(fileName):
inf = open(fileName, "r")
disNum = int(inf.read(1))
patNum = int(inf.readline().strip())
disDict = {} #disDict dict
sympDict = {} #sympDict dict
disName=[]
symName=[]
#reading file, storing diseases and sympDict probabilities
for i in range(disNum):
disInfo=inf.readline().split() #String to store disInfo line in a string
disDict[disInfo[0]]={} #making disInfo values 0
disName.append(disInfo[0]); #adding to list of disDict names
disDict[disInfo[0]]["symp"]=int(disInfo[1])
disDict[disInfo[0]]["prob"]=float(disInfo[2])
#print(disDict)
S4DList=eval(inf.readline()) #making list of symp
posProb=eval(inf.readline()) #making list of P(s|d)
negProb=eval(inf.readline()) #making list of P(s|d')
sympDict[disInfo[0]]={} #symp(disInfo)=null
symName.append(S4DList) #adding to list of symptom names
for j in range(disDict[disInfo[0]]["symp"]):
sympDict[disInfo[0]][S4DList[j]]={}
sympDict[disInfo[0]][S4DList[j]]["pos"]=float(posProb[j])
sympDict[disInfo[0]][S4DList[j]]["neg"]=float(negProb[j])
outputstr=""
#reading patients data from file and their calculations
for i in range(patNum):
patDict={} #pat dict
outputstr+="Patient-"+str(i+1)+":\n"
#print(str1)
#reading data
for d in range(disNum):
patDict[disName[d]]={} #dict within a dict
patInfo=eval(inf.readline())
for s in range(disDict[disName[d]]["symp"]):
patDict[disName[d]][symName[d][s]]=patInfo[s]
#question 1
op1={}
for d in disDict:
num=disDict[d]["prob"]
den=1-disDict[d]["prob"]
for s in sympDict[d]:
if patDict[d][s]=='T':
num*=sympDict[d][s]["pos"]
den*=sympDict[d][s]["neg"]
elif patDict[d][s]=='F':
num*=(1-sympDict[d][s]["pos"])
den*=(1-sympDict[d][s]["neg"])
ans=num/(num+den)
ans=round(ans,4)
op1[d]=str(ans)
#print(op1)
outputstr+=str(op1)+"\n"
#question 2
op2={}
for d in disDict:
num=disDict[d]["prob"]
den=1-disDict[d]["prob"]
unProbList=[]
unSymList=[]
permList=[]
for s in sympDict[d]:
if patDict[d][s]=='T':
num*=sympDict[d][s]["pos"]
den*=sympDict[d][s]["neg"]
elif patDict[d][s]=='F':
num*=(1-sympDict[d][s]["pos"])
den*=(1-sympDict[d][s]["neg"])
elif patDict[d][s]=='U':
unSymList.append(s)
for i in range(len(unSymList)):
dummy=['T','F']
permList.append(dummy)
permList=list(itertools.product(*permList))
for i in range(len(permList)):
newNum=1
newDen=1
for j in range(len(unSymList)):
if permList[i][j]=='T':
newNum*=sympDict[d][unSymList[j]]["pos"]
newDen*=sympDict[d][unSymList[j]]["neg"]
elif permList[i][j]=='F':
newNum*=(1-sympDict[d][unSymList[j]]["pos"])
newDen*=(1-sympDict[d][unSymList[j]]["neg"])
ans=(num*newNum)/((num*newNum)+(den*newDen))
ans=round(ans,4)
ans="{0:.4f}".format(ans)
unProbList.append(ans)
op2[d]=[str((min(unProbList))),str((max(unProbList)))]
#print(op2)
outputstr+=str(op2)+"\n"
# question 3
op3={}
for d in disDict:
num=disDict[d]["prob"]
den=1-disDict[d]["prob"]
unValList=[]
unSymList=[]
maxA=0
minB=0
for s in sympDict[d]:
if patDict[d][s]=='T':
num*=sympDict[d][s]["pos"]
den*=sympDict[d][s]["neg"]
elif patDict[d][s]=='F':
num*=(1-sympDict[d][s]["pos"])
den*=(1-sympDict[d][s]["neg"])
elif patDict[d][s]=='U':
unSymList.append(s)
for i in range(len(unSymList)):
#unknown is true
newNum=num*sympDict[d][unSymList[i]]["pos"]
newDen=den*sympDict[d][unSymList[i]]["neg"]
ans=newNum/(newNum+newDen)
if i==0:
maxA=ans
unValList.append(unSymList[i])
unValList.append('T')
minB=ans
unValList.append(unSymList[i])
unValList.append('T')
else:
if ans>maxA:
maxA=ans
unValList[0]=unSymList[i]
unValList[1]='T'
if ans<minB:
minB=ans
unValList[2]=unSymList[i]
unValList[3]='T'
#unknown is false
newNum=num*(1-sympDict[d][unSymList[i]]["pos"])
newDen=den*(1-sympDict[d][unSymList[i]]["neg"])
ans=newNum/(newNum+newDen)
if ans>maxA:
maxA=ans
unValList[0]=unSymList[i]
unValList[1]='F'
if ans<minB:
minB=ans
unValList[2]=unSymList[i]
unValList[3]='F'
op3[d]=unValList
#print(op3)
outputstr+=str(op3)+"\n"
inf.close()
return outputstr
def _get_partition_specs(self, listattr):
prod = itertools.product(*listattr)
return [('None', [item[0]], [item[1]]) for item in prod]
def beta_stats(mask_area, test_field="encoding", test=["F", "L"], **kwargs):
default_config = {
"encoding": ["F", "L"],
"level": ["3"],
"response" :["C"],
}
condition_dir_dict = {
"encoding":0,
"level":1,
"response":2
}
encoding = default_config["encoding"]
level = default_config["level"]
response = default_config["response"]
items = itertools.product(encoding, level, response)
conditions = ["".join(v) for v in items]
path = "/home/robbis/mount/wkpsy01/fmri/carlo_ofp/0_results/"
import glob
pattern = "0_beta_%s_%s_total.nii.gz"
maps = dict()
for condition in default_config[test_field]:
condition_pattern = [v for v in conditions if v.find(condition)!=-1]
print condition_pattern
condition_pattern.sort()
rocfile = glob.glob(os.path.join(path, pattern % (mask_area, "_".join(condition_pattern))))
print rocfile
map[condition] = ni.load(rocfile[0])
from scipy.stats import ttest_ind
t, p = ttest_ind(map[test[0]].get_data(), map[test[1]].get_data(), axis=3)
q = np.zeros_like(p)
q[np.logical_not(p == 0)] = 1 - p[np.logical_not(p == 0)]
t[np.isinf(t)] = 0
p[np.isnan(p)] = 0
def get_image(img):
return ni.Nifti1Image(img, map[test[0]].affine)
def get_name(mask_area, test, map_type):
pattern = "0_beta_ttest_%s_%s_%s_3.nii.gz" % (mask_area, "_".join(test), map_type)
return pattern
ni.save(get_image(q), os.path.join(path, get_name(mask_area, test, "q")))
ni.save(get_image(p), os.path.join(path, get_name(mask_area, test, "p")))
ni.save(get_image(t), os.path.join(path, get_name(mask_area, test, "t")))
def IncrementAlphaHarness_ICs(recalculate = False,
num_iterates = 20,
Tf = 1.,
tau_chars = [.5,2],
mus = [-1,1],
step_size = 5.):
sigma = 1.;
params = array([sigma]);
amax = 1
alpha_bounds = [-amax, amax];
alpha_bang_bang = lambda x: amax* sign(x)
alpha_forward = lambda x: arctan(5*x) / (pi/ 2.) * amax
alpha_null = lambda x: .0*x
alpha_H1 = lambda x: amax* sign(x)*(abs(x) > 1.)
dt = .01; num_nodes = 200;
lSolver = FBSolver(dt, Tf, num_nodes, xmin=-5., xmax=5.)
thetas = list( itertools.product(mus, tau_chars))
pThetas = ones(len(thetas)) / len(thetas);
file_name = 'alpha_iterates_uICs_Tf=%.1f'%Tf
if recalculate:
FBSolnsList = []
xs = lSolver._xs;
width = 2.0; x_0 = .0;
pre_ICs = exp(-(xs-x_0)**2 / width**2) / (width * sqrt(pi))
ICs = pre_ICs / (sum(pre_ICs)*lSolver._dx)
#Calculate bang-bang reference:
alphas = lSolver.generateAlphaField(alpha_bang_bang);
xs, ts, fs, ps, J, grad_J = lSolver.solve(thetas, pThetas,
params, alphas,
ICs,
visualize=False)
(FBSolution(params, thetas, pThetas, xs, ts,
fs, ps, alphas, grad_J, J)).save('alpha_bang_bang')
print 'J_bang_bang = ', J
#Calculate null reference:
alphas = lSolver.generateAlphaField(alpha_null);
xs, ts, fs, ps, J, grad_J = lSolver.solve(thetas, pThetas,
params, alphas,
ICs,
visualize=False)
(FBSolution(params, thetas, pThetas, xs, ts,
fs, ps, alphas, grad_J, J)).save('alpha_null')
#NOw reset to the Null Solution:
print 'ICs for alphas = bang-null-bang'
alphas = lSolver.generateAlphaField(alpha_H1);
for ak in xrange(num_iterates):
xs, ts, fs, ps, J, grad_J = lSolver.solve(thetas, pThetas,
params, alphas,
ICs,
visualize=False)
print ak, J
fbSoln = FBSolution(params, thetas, pThetas,
xs, ts, fs, ps,
alphas, grad_J, J)
FBSolnsList.append(fbSoln)
#calculate next alpha field:
alphas = incrementAlpha(alphas, grad_J,
step_size=step_size,
alpha_max=amax)
FBIterates(FBSolnsList).save(file_name)
#//Resimulate
#Load:
FBSolnsList = (FBIterates.load(file_name))._iteratesList
num_iterates = len(FBSolnsList);
#Visualize controls:
# tks = [1, 20, 40,60,80, 99]
# tks = array([1, 3, 10, 40, 60, 90, 97, 99])*int(Tf)
tks = array([ 5, 20, 50, 80, 95 ])*int(Tf)
# aks = [5, 10, 14, 16, 18, len(FBSolnsList)-1];
# aks = [16, num_iterates - 1];
aks = [0, int((num_iterates - 1)/2), num_iterates - 1];
soln_fig = figure(figsize = (17,18));
subplots_adjust(hspace = .2,wspace = .35,
left=.05, right=1.,
top = .95, bottom = .05)
num_rows = len(tks);
num_cols = 3;
for row_idx, tk in enumerate(tks):
for ak in aks:
FBSoln = FBSolnsList[ak]
plt_idx = row_idx*num_cols;
xs = FBSoln._xs;
ts = FBSoln._ts;
fs, ps, alphas = FBSoln._fs, FBSoln._ps,FBSoln._alphas;
tc_idx = 0;
#fs:
ax = soln_fig.add_subplot(num_rows, num_cols, plt_idx+1)
ax.plot(xs, fs[tc_idx, tk,:], label='k=%d'%ak);
if tk == tks[1]:
ax.set_ylabel(r'$f_{\mu=%.1g, \tau=%.1g}$'%(thetas[tc_idx][0],thetas[tc_idx][1]),
fontsize = xlabel_font_size)
# ax.set_ylim((.0, 2.0))
#ps:
ax = soln_fig.add_subplot(num_rows, num_cols, plt_idx+2)
ax.plot(xs, ps[tc_idx, tk,:], label='k=%d'%ak);
if tk == tks[1]:
ax.set_ylabel(r'$p_{\mu=%.1g, \tau=%.1g}$'%(thetas[tc_idx][0], thetas[tc_idx][1]),
fontsize = xlabel_font_size)
# ax.set_ylim((.0, 2.0))
#alphas:
ax = soln_fig.add_subplot(num_rows, num_cols, plt_idx+3)
ax.plot(xs, alphas[tk,:], label='k=%d'%ak);
if tk == tks[1]:
ax.set_ylabel(r'$\alpha_k$', fontsize = xlabel_font_size)
#common to all drawing:
for col_idx in xrange(1,num_cols+1):
ax = soln_fig.add_subplot(num_rows, num_cols, plt_idx+col_idx)
ax.set_title('t=%.2f'%ts[tk], fontsize = xlabel_font_size)
# ax.vlines(0,ax.get_ylim()[0], ax.get_ylim()[1],linestyles='dashed')
# ax.hlines(0,ax.get_xlim()[0], ax.get_xlim()[1],linestyles='dashed')
ax.set_xlim(xs[0], xs[-1])
if tk == tks[0]:
ax.legend(prop={'size':label_font_size})
if tk == tks[-1]:
ax.set_xlabel('$x$', fontsize = xlabel_font_size);
else:
for x in ax.get_xticklabels():
x.set_visible(False)
#J figure:
Js = [fb._J for fb in FBSolnsList];
fbBangSoln = FBSolution.load('alpha_bang_bang')
fbNullSoln = FBSolution.load('alpha_null')
J_null = fbNullSoln._J;
J_bangbang = fbBangSoln._J;
J_fig = figure(figsize = (17,6));
subplots_adjust(left=.025, right=1.,
top = .95, bottom = .05)
ax = J_fig.add_subplot(111);
J_fig.subplots_adjust(left=.025, right=1.,
top = .95, bottom = .05)
ax = J_fig.add_subplot(111);
ax.plot(Js, 'b', label='Gradient Ascent');
ax.plot(J_bangbang*ones_like(Js), 'r', label='Bang-Bang')
ax.plot(J_null*ones_like(Js), 'g', label=r'Do nothing ($\alpha =0$)')
ax.set_ylim([0., ceil(J_bangbang) ]);
ax.legend(loc = 'lower right', prop={'size':label_font_size})
#
ax.set_ylabel(r'$J_{k}$', fontsize = xlabel_font_size);
ax.set_xlabel('k', fontsize = xlabel_font_size)
ax.set_title('$J$ evolution', fontsize = xlabel_font_size);
#Save figs:
for fig, fig_name in zip([soln_fig, J_fig],
['FB_alpha_iterates_uICs_%d'%len(tks),
'FB_J_iterates_uICs']):
# fig.canvas.manager.window.showMaximized()
lfig_name = os.path.join(FIGS_DIR, fig_name + '_Tf=%d.pdf'%(ceil(Tf)))
print 'saving to ', lfig_name
save_ret_val = fig.savefig(lfig_name, dpi=300)
# encoding=UTF-8
'''
Created on 2013-7-18
@author: Administrator
'''
from timeit import itertools
from random import random, Random
import datetime
src = list(itertools.product(range(0, 10), repeat=5))
random = Random()
tdelta = datetime.timedelta(seconds=1)
def gen(filename, start, end, filters):
with open(filename, 'w') as f:
dt = start
while dt < end:
f.write(dt.strftime("%Y%m%d%H%M%S") + ":" + u",".join(map(unicode, random.choice(src))) + "\n")
dt = dt + tdelta
if filters is not None and dt < end and filters(dt):
print 'next ' + dt.strftime("%Y-%m-%d %H:%M:%S")
print 'finish write to ' + filename + "from " + start.strftime("%Y-%m-%d %H:%M:%S") + " to " + end.strftime("%Y-%m-%d %H:%M:%S")
if __name__ == '__main__':
gen(r"D:\test\hadoop_src\2013",
datetime.datetime(2013, 01, 01, 0, 0, 0),
datetime.datetime(2013, 02, 01, 0, 0, 0),
lambda dt:dt.hour == 0 and dt.minute == 0 and dt.second == 0)
