double spatial_Bspline03_integralf(double alpha)
{
XX(global_aux) = XX(global_r) + alpha * XX(global_u);
YY(global_aux) = YY(global_r) + alpha * YY(global_u);
ZZ(global_aux) = ZZ(global_r) + alpha * ZZ(global_u);
return spatial_Bspline03LUT(global_aux);
}
static long ZZ_remove(struct ZZ &dest, const struct ZZ &src, const struct ZZ &f)
{
// Based on the code for mpz_remove
ZZ fpow[40]; // inexaustible...until year 2020 or so
ZZ x, rem;
long pwr;
int p;
if (compare(f, 1) <= 0 && compare(f, -1) >= 0)
Error("Division by zero");
if (compare(src, 0) == 0)
{
if (src != dest)
dest = src;
return 0;
}
if (compare(f, 2) == 0)
{
dest = src;
return MakeOdd(dest);
}
/* We could perhaps compute mpz_scan1(src,0)/mpz_scan1(f,0). It is an
upper bound of the result we're seeking. We could also shift down the
operands so that they become odd, to make intermediate values smaller. */
pwr = 0;
fpow[0] = ZZ(f);
dest = src;
rem = ZZ();
x = ZZ();
/* Divide by f, f^2, ..., f^(2^k) until we get a remainder for f^(2^k). */
for (p = 0;;p++)
{
DivRem(x, rem, dest, fpow[p]);
if (compare(rem, 0) != 0)
break;
fpow[p+1] = ZZ();
NTL::mul(fpow[p+1], fpow[p], fpow[p]);
dest = x;
}
pwr = (1 << p) - 1;
/* Divide by f^(2^(k-1)), f^(2^(k-2)), ..., f for all divisors that give a
zero remainder. */
while (--p >= 0)
{
DivRem(x, rem, dest, fpow[p]);
if (compare(rem, 0) == 0)
{
pwr += 1 << p;
dest = x;
}
}
return pwr;
}
// Remove wedge ------------------------------------------------------------
void MissingWedge::removeWedge(MultidimArray<double> &V) const
{
Matrix2D<double> Epos, Eneg;
Euler_angles2matrix(rotPos,tiltPos,0,Epos);
Euler_angles2matrix(rotNeg,tiltNeg,0,Eneg);
Matrix1D<double> freq(3), freqPos, freqNeg;
Matrix1D<int> idx(3);
FourierTransformer transformer;
MultidimArray< std::complex<double> > Vfft;
transformer.FourierTransform(V,Vfft,false);
FOR_ALL_ELEMENTS_IN_ARRAY3D(Vfft)
{
// Frequency in the coordinate system of the volume
VECTOR_R3(idx,j,i,k);
FFT_idx2digfreq(V,idx,freq);
// Frequency in the coordinate system of the plane
freqPos=Epos*freq;
freqNeg=Eneg*freq;
if (ZZ(freqPos)<0 || ZZ(freqNeg)>0)
Vfft(k,i,j)=0;
}
transformer.inverseFourierTransform();
}
// Computes sum of the values of a unitary blob on grid points. The blob is
// supposed to be at the origin of the absolute coordinate system
double sum_blob_SimpleGrid(const struct blobtype &blob, const SimpleGrid &grid,
const Matrix2D<double> *D)
{
SPEED_UP_temps012;
Matrix1D<double> gr(3), ur(3), corner1(3), corner2(3);
double actual_radius;
int i, j, k;
double sum = 0.0;
// Compute the limits of the blob in the grid coordinate system
grid.universe2grid(vectorR3(-blob.radius, -blob.radius, -blob.radius), corner1);
grid.universe2grid(vectorR3(blob.radius, blob.radius, blob.radius), corner2);
if (D != NULL)
box_enclosing(corner1, corner2, *D, corner1, corner2);
// Compute the sum in the points inside the grid
// The integer part of the vectors is taken for not picking points
// just in the border of the blob, which we know they are 0.
for (i = (int)XX(corner1); i <= (int)XX(corner2); i++)
for (j = (int)YY(corner1); j <= (int)YY(corner2); j++)
for (k = (int)ZZ(corner1); k <= (int)ZZ(corner2); k++)
{
VECTOR_R3(gr, i, j, k);
grid.grid2universe(gr, ur);
if (D != NULL)
M3x3_BY_V3x1(ur, *D, ur);
actual_radius = ur.module();
if (actual_radius < blob.radius)
sum += kaiser_value(actual_radius,
blob.radius, blob.alpha, blob.order);
}
return sum;
}
// Sets the prime defining the field for the curve and stores certain values
void Icart::setPrime(ZZ* p)
{
//ZZ_p::init(*p);
// Icart hash function uses 1/3 root, which is equivalent to (2p-1)/3
exp = MulMod( SubMod( MulMod(ZZ(2), *p, *p), ZZ(1), *p), InvMod(ZZ(3),*p), *p);
// Store inverse values to be used later
ts = inv(ZZ_p(27));
th = inv(ZZ_p(3));
}
int main()
{
setbuf(stdout, NULL);
for (long l = 256; l <= 16384; l *= 2) {
// for (long n = 256; n <= 16384; n *= 2) {
for (long idx = 0; idx < 13; idx ++) {
long n = 256*(1L << idx/2);
if (idx & 1) n += n/2;
SetSeed((ZZ(l) << 64) + ZZ(n));
ZZX a, b, c;
a.SetLength(n);
for (long i = 0; i < n; i++) RandomBits(a[i], l);
a.normalize();
b.SetLength(n);
for (long i = 0; i < n; i++) RandomBits(b[i], l);
b.normalize();
double t;
mul(c, a, b);
long iter = 1;
do {
t = GetTime();
for (long i = 0; i < iter; i++) mul(c, a, b);
t = GetTime() - t;
iter *= 2;
} while (t < 3);
iter /= 2;
t = GetTime();
for (long i = 0; i < iter; i++) mul(c, a, b);
t = GetTime()-t;
double NTLTime = t;
FlintZZX f_a(a), f_b(b), f_c(c);
fmpz_poly_mul(f_c.value, f_a.value, f_b.value);
t = GetTime();
for (long i = 0; i < iter; i++) fmpz_poly_mul(f_c.value, f_a.value, f_b.value);
t = GetTime()-t;
double FlintTime = t;
printf("%8.2f", FlintTime/NTLTime);
}
printf("\n");
}
}
// Apply transformation ---------------------------------------------------
void applyTransformation(const MultidimArray<double> &V2,
MultidimArray<double> &Vaux,
double *p)
{
Matrix1D<double> r(3);
Matrix2D<double> A, Aaux;
double greyScale = p[0];
double greyShift = p[1];
double rot = p[2];
double tilt = p[3];
double psi = p[4];
double scale = p[5];
ZZ(r) = p[6];
YY(r) = p[7];
XX(r) = p[8];
Euler_angles2matrix(rot, tilt, psi, A, true);
translation3DMatrix(r,Aaux);
A = A * Aaux;
scale3DMatrix(vectorR3(scale, scale, scale),Aaux);
A = A * Aaux;
applyGeometry(LINEAR, Vaux, V2, A, IS_NOT_INV, WRAP);
if (greyScale!=1 || greyShift!=0)
FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(Vaux)
DIRECT_MULTIDIM_ELEM(Vaux,n)=DIRECT_MULTIDIM_ELEM(Vaux,n)*greyScale+greyShift;
}
static int bloch_jacobian(long int N, realtype t,
N_Vector M, N_Vector fM, DlsMat J, void *user_data,
N_Vector tmp1, N_Vector tmp2, N_Vector tmp3)
{
struct bloch_sim *bs = (struct bloch_sim*)user_data;
int i;
for (i=0; i < bs->num_cells; ++i)
{
realtype dw = bs->cell_frequencies[i] - bs->w_avg;
realtype w_1 = bs->rf_on ? bs->w_1 : 0.0;
XX(J,i) = -1 / bs->T_2;
XY(J,i) = dw;
XZ(J,i) = 0.0;
YX(J,i) = -dw;
YY(J,i) = -1 / bs->T_2;
YZ(J,i) = w_1;
ZX(J,i) = 0.0;
ZY(J,i) = -w_1;
ZZ(J,i) = -1 / bs->T_1;
}
return 0;
}
static pair<ZZ,int> factModExp(int n) {
if (n == 0) return MP(1, 0);
int e = n / MOD;
pair<ZZ,int> pr = factModExp(e);
if (e % 2) {
return MP(ZZ(0) - pr.first * fact(n % MOD), pr.second + e);
} else {
return MP(pr.first * fact(n % MOD), pr.second + e);
}
}
int main(int argc, char *argv[])
{
ArgMapping amap;
long p=2;
long r=1;
long c=3;
long L=600;
long N=0;
long t=0;
long nthreads=1;
long seed=0;
long useCache=1;
amap.arg("p", p, "plaintext base");
amap.arg("r", r, "exponent");
amap.note("p^r is the plaintext-space modulus");
amap.arg("c", c, "number of columns in the key-switching matrices");
amap.arg("L", L, "# of levels in the modulus chain");
amap.arg("N", N, "lower-bound on phi(m)");
amap.arg("t", t, "Hamming weight of recryption secret key", "heuristic");
amap.arg("dry", dry, "dry=1 for a dry-run");
amap.arg("nthreads", nthreads, "number of threads");
amap.arg("seed", seed, "random number seed");
amap.arg("noPrint", noPrint, "suppress printouts");
amap.arg("useCache", useCache, "0: zzX cache, 1: DCRT cache");
amap.arg("force_bsgs", fhe_test_force_bsgs);
amap.arg("force_hoist", fhe_test_force_hoist);
// amap.arg("disable_intFactor", fhe_disable_intFactor);
amap.arg("chen_han", fhe_force_chen_han);
amap.arg("debug", debug, "generate debugging output");
amap.arg("scale", scale, "scale parameter");
amap.parse(argc, argv);
if (seed)
SetSeed(ZZ(seed));
SetNumThreads(nthreads);
for (long i=0; i<(long)num_mValues; i++)
if (mValues[i][0]==p && mValues[i][1]>=N) {
TestIt(i,p,r,L,c,t,useCache);
break;
}
return 0;
}
std::string Ioss::Sym_Tensor_31::label(int which, const char) const
{
assert(which > 0 && which <= component_count());
switch(which) {
case 1: return XX();
case 2: return YY();
case 3: return ZZ();
case 4: return XY();
default: return "";
}
}
/* Sum spline on a grid ---------------------------------------------------- */
double sum_spatial_Bspline03_SimpleGrid(const SimpleGrid &grid)
{
Matrix1D<double> gr(3), ur(3), corner1(3), corner2(3);
int i, j, k;
double sum = 0.0;
// Compute the limits of the spline in the grid coordinate system
grid.universe2grid(vectorR3(-2.0, -2.0, -2.0), corner1);
grid.universe2grid(vectorR3(2.0, 2.0, 2.0), corner2);
// Compute the sum in the points inside the grid
// The integer part of the vectors is taken for not picking points
// just in the border of the spline, which we know they are 0.
for (i = (int)XX(corner1); i <= (int)XX(corner2); i++)
for (j = (int)YY(corner1); j <= (int)YY(corner2); j++)
for (k = (int)ZZ(corner1); k <= (int)ZZ(corner2); k++)
{
VECTOR_R3(gr, i, j, k);
grid.grid2universe(gr, ur);
sum += spatial_Bspline03(ur);
}
return sum;
}
// Draw wedge --------------------------------------------------------------
void drawWedge(double rotPos, double tiltPos, double rotNeg, double tiltNeg,
const MultidimArray<double> *V,
const MultidimArray<double> *Vmag, MultidimArray<double> *Vdraw)
{
Matrix2D<double> Epos, Eneg;
Euler_angles2matrix(rotPos,tiltPos,0,Epos);
Euler_angles2matrix(rotNeg,tiltNeg,0,Eneg);
Matrix1D<double> freq(3), freqPos, freqNeg;
Matrix1D<int> idx(3);
Vdraw->initZeros(*Vmag);
FOR_ALL_ELEMENTS_IN_ARRAY3D(*Vdraw)
{
// Frequency in the coordinate system of the volume
VECTOR_R3(idx,j,i,k);
FFT_idx2digfreq(*V,idx,freq);
// Frequency in the coordinate system of the plane
freqPos=Epos*freq;
freqNeg=Eneg*freq;
if (ZZ(freqPos)<0 || ZZ(freqNeg)>0)
(*Vdraw)(k,i,j)+=1;
}
}
ISOIEC_DSS(const DSSDomainParameters<EC_Dscr> & DomainParameters,
generateRandomValueCallback & PRNG)
: _DomainParameters(DomainParameters),
_Curve(_DomainParameters.EC),
_PCurve(_DomainParameters.EC),
_privateKey(ZZ()),
_publicKey(_PCurve.create()),
_isPrivateKeyLoaded(false),
_isPublicKeyLoaded(false),
_Ln(L(_DomainParameters.EC.getOrder())),
_Lcm(L(_DomainParameters.EC.getModulus())),
_BasePoint(_PCurve.getBasePoint()),
_PRNG(PRNG)
{
/* TODO: Input policy sanity checks */
}
std::string Ioss::Matrix_33::label(int which, const char) const
{
assert(which > 0 && which <= component_count());
switch(which) {
case 1: return XX();
case 2: return XY();
case 3: return XZ();
case 4: return YX();
case 5: return YY();
case 6: return YZ();
case 7: return ZX();
case 8: return ZY();
case 9: return ZZ();
default: return "";
}
}
// Icart's hash function
EPoint Icart::hash(ZZ_p u)
{
// 0 maps to the point at infinity
if (IsZero(u))
{
return EPoint(ZZ_p(0), ZZ_p(0), true);
}
// v = (3a - u^4) / 6u
ZZ_p v = ((ZZ_p(3) * a) - power(u, 4)) * inv(ZZ_p(6) * u);
// x = (v^2 - b - u^6/27)^(1/3) + u^2/3
ZZ_p x = power( sqr(v) - b - (power(u, ZZ(6)) * ts), exp) + (sqr(u) * th);
// y = ux + v
ZZ_p y = (u * x) + v;
return EPoint(x, y, false);
}
// Write PDB format
void Assembly::writePDB(std::string filename)
{
FILE *file;
file = fopen(filename.c_str(), "w");
if (file==NULL)
REPORT_ERROR("Error writing file: " + filename);
fprintf(file, "%s\n", "REMARK Created by DsigNA");
long int atomnum = 0;
for (int imol = 0; imol < molecules.size(); imol++)
{
for (int ires = 0; ires < molecules[imol].residues.size(); ires++)
{
for (int iatom = 0; iatom < molecules[imol].residues[ires].atoms.size(); iatom++, atomnum++)
{
// If more than 100,000 atoms: just start counting at one again.
if (atomnum > 99999)
atomnum -= 99999;
char chainID = molecules[imol].name[0];
fprintf(file, "ATOM %5d %-4s %3s %1c%4d %8.3f%8.3f%8.3f%6.2f%6.2f %4s\n",
atomnum, molecules[imol].residues[ires].atoms[iatom].name.c_str(), molecules[imol].residues[ires].name.c_str(),
chainID, molecules[imol].residues[ires].number,
XX(molecules[imol].residues[ires].atoms[iatom].coords),
YY(molecules[imol].residues[ires].atoms[iatom].coords),
ZZ(molecules[imol].residues[ires].atoms[iatom].coords),
molecules[imol].residues[ires].atoms[iatom].occupancy,
molecules[imol].residues[ires].atoms[iatom].bfactor,
molecules[imol].name.c_str());
}
}
if (imol + 1 < molecules.size())
fprintf(file, "%s\n", "TER");
}
fprintf(file, "%s\n", "END");
fclose(file);
}
void Coordinates::update(void)
{
Matrix M1, M2;
selfTest();
M1.loadIdentity(); M1.translate(On);
M2.newUVN(Xn,Yn,Zn);
mO2N = M1 * M2;//Old->New
Vector XX(1,0,0),YY(0,1,0),ZZ(0,0,1);
fPoint o(0,0,0);
o = o * mO2N;
M1.loadIdentity(); M1.translate(o);
XX = XX * mO2N; YY = YY * mO2N; ZZ = ZZ * mO2N;
/*
printf("\n------On------\n");o.outputs();
printf("\n------XXn------\n");XX.outputs();
printf("\n------YYn------\n");YY.outputs();
printf("\n------ZZn------\n");ZZ.outputs();
*/
M2.newUVN(XX,YY,ZZ);
mN2O = M1 * M2;//New -> Old
}
void ProgAngularProjectLibrary::project_angle_vector (int my_init, int my_end, bool verbose)
{
Projection P;
FileName fn_proj;
double rot,tilt,psi;
int mySize;
int numberStepsPsi = 1;
mySize=my_end-my_init+1;
if (psi_sampling < 360)
{
numberStepsPsi = (int) (359.99999/psi_sampling);
mySize *= numberStepsPsi;
}
if (verbose)
init_progress_bar(mySize);
int myCounter=0;
for (double mypsi=0;mypsi<360;mypsi += psi_sampling)
for (int i=0;i<my_init;i++)
myCounter++;
// if (shears && XSIZE(inputVol())!=0 && VShears==NULL)
// VShears=new RealShearsInfo(inputVol());
if (projType == SHEARS && XSIZE(inputVol())!=0 && Vshears==NULL)
Vshears=new RealShearsInfo(inputVol());
if (projType == FOURIER && XSIZE(inputVol())!=0 && Vfourier==NULL)
Vfourier=new FourierProjector(inputVol(),
paddFactor,
maxFrequency,
BSplineDeg);
for (double mypsi=0;mypsi<360;mypsi += psi_sampling)
{
for (int i=my_init;i<=my_end;i++)
{
if (verbose)
progress_bar(i-my_init);
psi= mypsi+ZZ(mysampling.no_redundant_sampling_points_angles[i]);
tilt= YY(mysampling.no_redundant_sampling_points_angles[i]);
rot= XX(mysampling.no_redundant_sampling_points_angles[i]);
// if (shears)
// projectVolume(*VShears, P, Ydim, Xdim, rot,tilt,psi);
// else
// projectVolume(inputVol(), P, Ydim, Xdim, rot,tilt,psi);
if (projType == SHEARS)
projectVolume(*Vshears, P, Ydim, Xdim, rot, tilt, psi);
else if (projType == FOURIER)
projectVolume(*Vfourier, P, Ydim, Xdim, rot, tilt, psi);
else if (projType == REALSPACE)
projectVolume(inputVol(), P, Ydim, Xdim, rot, tilt, psi);
P.setEulerAngles(rot,tilt,psi);
P.setDataMode(_DATA_ALL);
P.write(output_file,(size_t) (numberStepsPsi * i + mypsi +1),true,WRITE_REPLACE);
}
}
if (verbose)
progress_bar(mySize);
}
NTL_CLIENT
//namespace NTL { extern double ip_time; }
int main(int argc, char **argv)
{
ArgMapping amap;
long n = 1024;
amap.arg("n", n, "degree bound");
long l = 1024;
amap.arg("l", l, "coeff bound");
long nt = 1;
amap.arg("nt", nt, "num threads");
amap.parse(argc, argv);
cerr << "\n\n=============================\n\n";
cerr << "n=" << n << "\n";
cerr << "l=" << l << "\n";
cerr << "nt=" << nt << "\n";
SetSeed(ZZ(0));
SetNumThreads(nt);
ZZ p;
RandomPrime(p, l);
ZZ_p::init(p);
ZZ_pX f;
random(f, n);
SetCoeff(f, n);
Vec< Pair<ZZ_pX, long> > fac;
double t;
ZZ_pXFileThresh = 1e9;
FILE *fp;
unsigned long A[4], B[4];
int loadavg;
fp = fopen("/proc/stat","r");
fscanf(fp,"cpu %lu %lu %lu %lu",&A[0],&A[1],&A[2],&A[3]);
fclose(fp);
t = GetTime();
CanZass(fac, f, 1);
t = GetTime()-t;
double NTLTime = t;
fp = fopen("/proc/stat","r");
fscanf(fp,"cpu %lu %lu %lu %lu",&B[0],&B[1],&B[2],&B[3]);
fclose(fp);
// we multiply by 20 -- that's the total number of cores
loadavg = int(100.0*20.0*double((B[0]+B[1]+B[2]) - (A[0]+A[1]+A[2])) /
double((B[0]+B[1]+B[2]+B[3]) - (A[0]+A[1]+A[2]+A[3])));
fprintf(stderr, "CPU utilization: %d\%\n",loadavg);
struct rusage rusage;
getrusage( RUSAGE_SELF, &rusage );
cerr << "MAX_RSS="<<rusage.ru_maxrss << "KB" << endl;
cerr << "Fac: " << t << "\n";
//cerr << "ip_time: " << ip_time << "\n";
delete NTLThreadPool;
NTLThreadPool = 0;
}
void * blobs2voxels_SimpleGrid( void * data )
{
ThreadBlobsToVoxels * thread_data = (ThreadBlobsToVoxels *) data;
const MultidimArray<double> *vol_blobs = thread_data->vol_blobs;
const SimpleGrid *grid = thread_data->grid;
const struct blobtype *blob = thread_data->blob;
MultidimArray<double> *vol_voxels = thread_data->vol_voxels;
const Matrix2D<double> *D = thread_data->D;
int istep = thread_data->istep;
MultidimArray<double> *vol_corr = thread_data->vol_corr;
const MultidimArray<double> *vol_mask = thread_data->vol_mask;
;
bool FORW = thread_data->FORW;
int eq_mode = thread_data->eq_mode;
int min_separation = thread_data->min_separation;
int z_planes = (int)(ZZ(grid->highest) - ZZ(grid->lowest) + 1);
Matrix2D<double> Dinv; // Inverse of D
Matrix1D<double> act_coord(3); // Coord: Actual position inside
// the voxel volume without deforming
Matrix1D<double> real_position(3); // Coord: actual position after
// applying the V transformation
Matrix1D<double> beginZ(3); // Coord: Voxel coordinates of the
// blob at the 3D point
// (z0,YY(lowest),XX(lowest))
Matrix1D<double> beginY(3); // Coord: Voxel coordinates of the
// blob at the 3D point
// (z0,y0,XX(lowest))
Matrix1D<double> corner2(3), corner1(3); // Coord: Corners of the
// blob in the voxel volume
Matrix1D<double> gcurrent(3); // Position in g of current point
MultidimArray<double> blob_table; // Something like a blobprint
// but with the values of the
// blob in space
double d; // Distance between the center
// of the blob and a voxel position
int id; // index inside the blob value
// table for tha blob value at
// a distance d
double intx, inty, intz; // Nearest integer voxel
int i, j, k; // Index within the blob volume
int process; // True if this blob has to be
// processed
double vol_correction=0; // Correction to apply to the
// volume when "projecting" back
SPEED_UP_temps012;
// Some aliases
#define x0 STARTINGX(*vol_voxels)
#define xF FINISHINGX(*vol_voxels)
#define y0 STARTINGY(*vol_voxels)
#define yF FINISHINGY(*vol_voxels)
#define z0 STARTINGZ(*vol_voxels)
#define zF FINISHINGZ(*vol_voxels)
#ifdef DEBUG
bool condition = !FORW;
if (condition)
{
(*vol_voxels)().printShape();
std::cout << std::endl;
std::cout << "x0= " << x0 << " xF= " << xF << std::endl;
std::cout << "y0= " << y0 << " yF= " << yF << std::endl;
std::cout << "z0= " << z0 << " zF= " << zF << std::endl;
std::cout << grid;
}
#endif
// Invert deformation matrix ............................................
if (D != NULL)
Dinv = D->inv();
// Compute a blob value table ...........................................
blob_table.resize((int)(blob->radius*istep + 1));
for (size_t i = 0; i < blob_table.xdim; i++)
{
A1D_ELEM(blob_table, i) = kaiser_value((double)i/istep, blob->radius, blob->alpha, blob->order);
#ifdef DEBUG_MORE
if (condition)
std::cout << "Blob (" << i << ") r=" << (double)i / istep <<
" val= " << A1D_ELEM(blob_table, i) << std::endl;
#endif
}
int assigned_slice;
do
{
assigned_slice = -1;
do
{
pthread_mutex_lock(&blobs_conv_mutex);
if( slices_processed == z_planes )
{
pthread_mutex_unlock(&blobs_conv_mutex);
return (void*)NULL;
}
for(int w = 0 ; w < z_planes ; w++ )
{
if( slices_status[w]==0 )
{
slices_status[w] = -1;
assigned_slice = w;
slices_processed++;
for( int in = (w-min_separation+1) ; in <= (w+min_separation-1 ) ; in ++ )
{
if( in != w )
{
if( ( in >= 0 ) && ( in < z_planes ))
{
if( slices_status[in] != -1 )
slices_status[in]++;
}
}
}
break;
}
}
pthread_mutex_unlock(&blobs_conv_mutex);
}
while( assigned_slice == -1);
// Convert the whole grid ...............................................
// Corner of the plane defined by Z. These coordinates are in the
// universal coord. system
Matrix1D<double> aux( grid->lowest );
k = (int)(assigned_slice + ZZ( grid->lowest ));
ZZ(aux) = k;
grid->grid2universe(aux, beginZ);
Matrix1D<double> grid_index(3);
// Corner of the row defined by Y
beginY = beginZ;
for (i = (int) YY(grid->lowest); i <= (int) YY(grid->highest); i++)
{
// First point in the row
act_coord = beginY;
for (j = (int) XX(grid->lowest); j <= (int) XX(grid->highest); j++)
{
VECTOR_R3(grid_index, j, i, k);
#ifdef DEBUG
if (condition)
{
printf("Dealing blob at (%d,%d,%d) = %f\n", j, i, k, A3D_ELEM(*vol_blobs, k, i, j));
std::cout << "Center of the blob "
<< act_coord.transpose() << std::endl;
}
#endif
// Place act_coord in its right place
if (D != NULL)
{
M3x3_BY_V3x1(real_position, *D, act_coord);
#ifdef DEBUG
if (condition)
std::cout << "Center of the blob moved to "
//ROB, the "moved" coordinates are in
// real_position not in act_coord
<< act_coord.transpose() << std::endl;
<< real_position.transpose() << std::endl;
#endif
// ROB This is OK if blob.radius is in Cartesian space as I
// think is the case
}
else
real_position = act_coord;
// These two corners are also real valued
process = true;
//ROB
//This is OK if blob.radius is in Cartesian space as I think is the case
V3_PLUS_CT(corner1, real_position, -blob->radius);
V3_PLUS_CT(corner2, real_position, blob->radius);
#ifdef DEFORM_BLOB_WHEN_IN_CRYSTAL
//ROB
//we do not need this, it is already in Cartesian space
//if (D!=NULL)
// box_enclosing(corner1,corner2, *D, corner1, corner2);
#endif
if (XX(corner1) >= xF)
process = false;
if (YY(corner1) >= yF)
process = false;
if (ZZ(corner1) >= zF)
process = false;
if (XX(corner2) <= x0)
process = false;
if (YY(corner2) <= y0)
process = false;
if (ZZ(corner2) <= z0)
process = false;
#ifdef DEBUG
if (!process && condition)
std::cout << " It is outside output volume\n";
#endif
if (!grid->is_interesting(real_position))
{
#ifdef DEBUG
if (process && condition)
std::cout << " It is not interesting\n";
#endif
process = false;
}
#ifdef DEBUG
if (condition)
{
std::cout << "Corner 1 for this point " << corner1.transpose() << std::endl;
std::cout << "Corner 2 for this point " << corner2.transpose() << std::endl;
}
#endif
if (process)
{
// Clip the corners to the volume borders
XX(corner1) = ROUND(CLIP(XX(corner1), x0, xF));
YY(corner1) = ROUND(CLIP(YY(corner1), y0, yF));
ZZ(corner1) = ROUND(CLIP(ZZ(corner1), z0, zF));
XX(corner2) = ROUND(CLIP(XX(corner2), x0, xF));
YY(corner2) = ROUND(CLIP(YY(corner2), y0, yF));
ZZ(corner2) = ROUND(CLIP(ZZ(corner2), z0, zF));
#ifdef DEBUG
if (condition)
{
std::cout << "Clipped and rounded Corner 1 " << corner1.transpose() << std::endl;
std::cout << "Clipped and rounded Corner 2 " << corner2.transpose() << std::endl;
}
#endif
if (!FORW)
switch (eq_mode)
{
case VARTK:
vol_correction = 0;
break;
case VMAXARTK:
vol_correction = -1e38;
break;
}
// Effectively convert
long N_eq;
N_eq = 0;
for (intz = ZZ(corner1); intz <= ZZ(corner2); intz++)
for (inty = YY(corner1); inty <= YY(corner2); inty++)
for (intx = XX(corner1); intx <= XX(corner2); intx++)
{
int iz = (int)intz, iy = (int)inty, ix = (int)intx;
if (vol_mask != NULL)
if (!A3D_ELEM(*vol_mask, iz, iy, ix))
continue;
// Compute distance to the center of the blob
VECTOR_R3(gcurrent, intx, inty, intz);
#ifdef DEFORM_BLOB_WHEN_IN_CRYSTAL
// ROB
//if (D!=NULL)
// M3x3_BY_V3x1(gcurrent,Dinv,gcurrent);
#endif
V3_MINUS_V3(gcurrent, real_position, gcurrent);
d = sqrt(XX(gcurrent) * XX(gcurrent) +
YY(gcurrent) * YY(gcurrent) +
ZZ(gcurrent) * ZZ(gcurrent));
if (d > blob->radius)
continue;
id = (int)(d * istep);
#ifdef DEBUG_MORE
if (condition)
{
std::cout << "At (" << intx << ","
<< inty << "," << intz << ") distance=" << d;
std::cout.flush();
}
#endif
// Add at that position the corresponding blob value
if (FORW)
{
A3D_ELEM(*vol_voxels, iz, iy, ix) +=
A3D_ELEM(*vol_blobs, k, i, j) *
A1D_ELEM(blob_table, id);
#ifdef DEBUG_MORE
if (condition)
{
std::cout << " adding " << A3D_ELEM(*vol_blobs, k, i, j)
<< " * " << A1D_ELEM(blob_table, id) << " = "
<< A3D_ELEM(*vol_blobs, k, i, j)*
A1D_ELEM(blob_table, id) << std::endl;
std::cout.flush();
}
#endif
if (vol_corr != NULL)
A3D_ELEM(*vol_corr, iz, iy, ix) +=
A1D_ELEM(blob_table, id) * A1D_ELEM(blob_table, id);
}
else
{
double contrib = A3D_ELEM(*vol_corr, iz, iy, ix) *
A1D_ELEM(blob_table, id);
switch (eq_mode)
{
case VARTK:
vol_correction += contrib;
N_eq++;
break;
case VMAXARTK:
if (contrib > vol_correction)
vol_correction = contrib;
break;
}
#ifdef DEBUG_MORE
if (condition)
{
std::cout << " adding " << A3D_ELEM(*vol_corr, iz, iy, ix)
<< " * " << A1D_ELEM(blob_table, id) << " = "
<< contrib << std::endl;
std::cout.flush();
}
#endif
}
}
if (N_eq == 0)
N_eq = 1;
if (!FORW)
{
A3D_ELEM(*vol_blobs, k, i, j) += vol_correction / N_eq;
#ifdef DEBUG_MORE
std::cout << " correction= " << vol_correction << std::endl
<< " Number of eqs= " << N_eq << std::endl
<< " Blob after correction= "
<< A3D_ELEM(*vol_blobs, k, i, j) << std::endl;
#endif
}
}
// Prepare for next iteration
XX(act_coord) = XX(act_coord) + grid->relative_size * (grid->basis)( 0, 0);
YY(act_coord) = YY(act_coord) + grid->relative_size * (grid->basis)( 1, 0);
ZZ(act_coord) = ZZ(act_coord) + grid->relative_size * (grid->basis)( 2, 0);
}
int main()
{
#ifdef NTL_LONG_LONG
if (sizeof(NTL_LL_TYPE) < 2*sizeof(long)) {
printf("999999999999999 ");
print_flag();
return 0;
}
#endif
SetSeed(ZZ(0));
long i, k;
k = 10*NTL_ZZ_NBITS;
for (i = 0; i < 10000; i++) {
ZZ a, b, c, d;
long da = RandomBnd(k);
long db = RandomBnd(k);
long dc = RandomBnd(k);
long dd = RandomBnd(k);
RandomLen(a, da); RandomLen(b, db); RandomLen(c, dc); RandomLen(d, dd);
if ((a + b)*(c + d) != c*a + d*a + c*b + d*b) {
printf("999999999999999 ");
print_flag();
return 0;
}
}
for (i = 0; i < 10000; i++) {
ZZ a, b, c;
long da = RandomBnd(k);
long db = RandomBnd(k);
long dc = RandomBnd(k) + 2;
RandomLen(a, da); RandomLen(b, db); RandomLen(c, dc);
if ( ( a * b ) % c != ((a % c) * (b % c)) % c ) {
printf("999999999999999 ");
print_flag();
return 0;
}
}
k = 1024;
ZZ x1, x2, x3;
double t;
long j;
RandomLen(x1, k);
RandomLen(x2, k);
long iter;
mul(x3, x1, x2);
iter = 1;
do {
t = GetTime();
for (i = 0; i < iter; i++) {
for (j = 0; j < 500; j++) mul(x3, x1, x2);
}
t = GetTime() - t;
iter = 2*iter;
} while(t < 1);
iter = iter/2;
iter = long((3/t)*iter) + 1;
double tvec[5];
long w;
for (w = 0; w < 5; w++) {
t = GetTime();
for (i = 0; i < iter; i++) {
for (j = 0; j < 500; j++) mul(x3, x1, x2);
}
t = GetTime() - t;
tvec[w] = t;
}
t = clean_data(tvec);
t = floor((t/iter)*1e14);
if (t < 0 || t >= 1e15)
printf("999999999999999 ");
else
printf("%015.0f ", t);
printf(" [%ld] ", iter);
print_flag();
return 0;
}
<< " Number of eqs= " << N_eq << std::endl
<< " Blob after correction= "
<< A3D_ELEM(*vol_blobs, k, i, j) << std::endl;
#endif
}
}
// Prepare for next iteration
XX(act_coord) = XX(act_coord) + grid->relative_size * (grid->basis)( 0, 0);
YY(act_coord) = YY(act_coord) + grid->relative_size * (grid->basis)( 1, 0);
ZZ(act_coord) = ZZ(act_coord) + grid->relative_size * (grid->basis)( 2, 0);
}
XX(beginY) = XX(beginY) + grid->relative_size * (grid->basis)( 0, 1);
YY(beginY) = YY(beginY) + grid->relative_size * (grid->basis)( 1, 1);
ZZ(beginY) = ZZ(beginY) + grid->relative_size * (grid->basis)( 2, 1);
}
pthread_mutex_lock(&blobs_conv_mutex);
for( int in = (assigned_slice-min_separation+1) ; in <= (assigned_slice+min_separation-1); in ++ )
{
if( in != assigned_slice )
{
if( ( in >= 0 ) && ( in < z_planes))
{
if( slices_status[in] != -1 )
slices_status[in]--;
}
}
}
int main(int argc, char *argv[])
{
// Commandline setup
ArgMapping amap;
long m=16;
long r=8;
long L=0;
double epsilon=0.01; // Accepted accuracy
long R=1;
long seed=0;
bool debug = false;
amap.arg("m", m, "Cyclotomic index");
amap.note("e.g., m=1024, m=2047");
amap.arg("r", r, "Bits of precision");
amap.arg("R", R, "number of rounds");
amap.arg("L", L, "Number of bits in modulus", "heuristic");
amap.arg("ep", epsilon, "Accepted accuracy");
amap.arg("seed", seed, "PRG seed");
amap.arg("verbose", verbose, "more printouts");
amap.arg("debug", debug, "for debugging");
amap.parse(argc, argv);
if (seed)
NTL::SetSeed(ZZ(seed));
if (R<=0) R=1;
if (R<=2)
L = 100*R;
else
L = 220*(R-1);
if (verbose) {
cout << "** m="<<m<<", #rounds="<<R<<", |q|="<<L
<< ", epsilon="<<epsilon<<endl;
}
epsilon /= R;
try{
// FHE setup keys, context, SKMs, etc
FHEcontext context(m, /*p=*/-1, r);
context.scale=4;
buildModChain(context, L, /*c=*/2);
FHESecKey secretKey(context);
secretKey.GenSecKey(); // A +-1/0 secret key
addSome1DMatrices(secretKey); // compute key-switching matrices
const FHEPubKey publicKey = secretKey;
const EncryptedArrayCx& ea = context.ea->getCx();
if (verbose) {
ea.getPAlgebra().printout();
cout << "r = " << context.alMod.getR() << endl;
cout << "ctxtPrimes="<<context.ctxtPrimes
<< ", specialPrimes="<<context.specialPrimes<<endl<<endl;
}
if (debug) {
dbgKey = & secretKey;
dbgEa = (EncryptedArray*) context.ea;
}
// Run the tests.
testBasicArith(publicKey, secretKey, ea, epsilon);
testComplexArith(publicKey, secretKey, ea, epsilon);
testRotsNShifts(publicKey, secretKey, ea, epsilon);
testGeneralOps(publicKey, secretKey, ea, epsilon*R, R);
}
catch (exception& e) {
cerr << e.what() << endl;
cerr << "***Major FAIL***" << endl;
}
return 0;
}
void ProgValidationTiltPairs::run()
{
MetaData MD_tilted, MD_untilted, DF1sorted, DF2sorted, DFweights;
MD_tilted.read(fntiltimage_In);
MD_untilted.read(fnuntiltimage_In);
DF1sorted.sort(MD_tilted,MDL_ITEM_ID,true);
DF2sorted.sort(MD_untilted,MDL_ITEM_ID,true);
MDIterator iter1(DF1sorted), iter2(DF2sorted);
std::vector< Matrix1D<double> > ang1, ang2;
Matrix1D<double> rotTiltPsi(3), z(3);
size_t currentId;
bool anotherImageIn2=iter2.hasNext();
size_t id1, id2;
bool mirror;
Matrix2D<double> Eu, Et, R;
double alpha, beta;
while (anotherImageIn2)
{
ang1.clear();
ang2.clear();
// Take current id
DF2sorted.getValue(MDL_ITEM_ID,currentId,iter2.objId);
// Grab all the angles in DF2 associated to this id
bool anotherIteration=false;
do
{
DF2sorted.getValue(MDL_ITEM_ID,id2,iter2.objId);
anotherIteration=false;
if (id2==currentId)
{
DF2sorted.getValue(MDL_ANGLE_ROT,XX(rotTiltPsi),iter2.objId);
DF2sorted.getValue(MDL_ANGLE_TILT,YY(rotTiltPsi),iter2.objId);
DF2sorted.getValue(MDL_ANGLE_PSI,ZZ(rotTiltPsi),iter2.objId);
DF2sorted.getValue(MDL_FLIP,mirror,iter2.objId);
std::cout << "From DF2:" << XX(rotTiltPsi) << " " << YY(rotTiltPsi) << " " << ZZ(rotTiltPsi) << " " << mirror << std::endl;
//LINEA ANTERIOR ORIGINAL
if (mirror)
{
double rotp, tiltp, psip;
Euler_mirrorX(XX(rotTiltPsi),YY(rotTiltPsi),ZZ(rotTiltPsi), rotp, tiltp, psip);
XX(rotTiltPsi)=rotp;
YY(rotTiltPsi)=tiltp;
ZZ(rotTiltPsi)=psip;
}
ang2.push_back(rotTiltPsi);
iter2.moveNext();
if (iter2.hasNext())
anotherIteration=true;
}
} while (anotherIteration);
// Advance Iter 1 to catch Iter 2
double N=0, cumulatedDistance=0;
size_t newObjId=0;
if (iter1.objId>0)
{
DF1sorted.getValue(MDL_ITEM_ID,id1,iter1.objId);
while (id1<currentId && iter1.hasNext())
{
iter1.moveNext();
DF1sorted.getValue(MDL_ITEM_ID,id1,iter1.objId);
}
// If we are at the end of DF1, then we did not find id1 such that id1==currentId
if (!iter1.hasNext())
break;
// Grab all the angles in DF1 associated to this id
anotherIteration=false;
do
{
DF1sorted.getValue(MDL_ITEM_ID,id1,iter1.objId);
anotherIteration=false;
if (id1==currentId)
{
DF1sorted.getValue(MDL_ANGLE_ROT,XX(rotTiltPsi),iter1.objId);
DF1sorted.getValue(MDL_ANGLE_TILT,YY(rotTiltPsi),iter1.objId);
DF1sorted.getValue(MDL_ANGLE_PSI,ZZ(rotTiltPsi),iter1.objId);
DF1sorted.getValue(MDL_FLIP,mirror,iter1.objId);
std::cout << "From DF1:" << XX(rotTiltPsi) << " " << YY(rotTiltPsi) << " " << ZZ(rotTiltPsi) << " " << mirror << std::endl;
//LINEA ANTERIOR ORIGINAL
if (mirror)
{
double rotp, tiltp, psip;
Euler_mirrorX(XX(rotTiltPsi),YY(rotTiltPsi),ZZ(rotTiltPsi), rotp, tiltp, psip);
XX(rotTiltPsi)=rotp;
YY(rotTiltPsi)=tiltp;
ZZ(rotTiltPsi)=psip;
}
ang1.push_back(rotTiltPsi);
iter1.moveNext();
if (iter1.hasNext())
anotherIteration=true;
}
} while (anotherIteration);
// Process both sets of angles
for (size_t i=0; i<ang2.size(); ++i)
{
const Matrix1D<double> &anglesi=ang2[i];
double rotu=XX(anglesi);
double tiltu=YY(anglesi);
double psiu=ZZ(anglesi);
Euler_angles2matrix(rotu,tiltu,psiu,Eu,false);
/*std::cout << "------UNTILTED MATRIX------" << std::endl;
std::cout << Eu << std::endl;
std::cout << "vector" << std::endl;
std::cout << Eu(2,0) << " " << Eu(2,1) << " " << Eu(2,2) << std::endl;*/
for (size_t j=0; j<ang1.size(); ++j)
{
const Matrix1D<double> &anglesj=ang1[j];
double rott=XX(anglesj);
double tiltt=YY(anglesj);
double psit=ZZ(anglesj);
double alpha_x, alpha_y;
Euler_angles2matrix(rott,tiltt,psit,Et,false);
//////////////////////////////////////////////////////////////////
double untilt_angles[3]={rotu, tiltu, psiu}, tilt_angles[3]={rott, tiltt, psit};
angles2tranformation(untilt_angles, tilt_angles, alpha_x, alpha_y);
//std::cout << "alpha = " << (alpha_x*alpha_x+alpha_y*alpha_y) << std::endl;
//////////////////////////////////////////////////////////////////
/*std::cout << "------TILTED MATRIX------" << std::endl;
std::cout << Et << std::endl;
std::cout << "vector" << std::endl;
std::cout << Et(2,0) << " " << Et(2,1) << " " << Et(2,2) << std::endl;
std::cout << "---------------------------" << std::endl;
std::cout << "---------------------------" << std::endl;*/
R=Eu*Et.transpose();
double rotTransf, tiltTransf, psiTransf;
Euler_matrix2angles(R, rotTransf, tiltTransf, psiTransf);
std::cout << "Rot_and_Tilt " << rotTransf << " " << tiltTransf << std::endl;
//LINEA ANTERIOR ORIGINAL
XX(z) = Eu(2,0) - Et(2,0);
YY(z) = Eu(2,1) - Et(2,1);
ZZ(z) = Eu(2,2) - Et(2,2);
alpha = atan2(YY(z), XX(z)); //Expressed in rad
beta = atan2(XX(z)/cos(alpha), ZZ(z)); //Expressed in rad
std::cout << "alpha = " << alpha*180/PI << std::endl;
std::cout << "beta = " << beta*180/PI << std::endl;
}
}
}
else
N=0;
if (N>0)
{
double meanDistance=cumulatedDistance/ang2.size();
DFweights.setValue(MDL_ANGLE_DIFF,meanDistance,newObjId);
}
else
if (newObjId>0)
DFweights.setValue(MDL_ANGLE_DIFF,-1.0,newObjId);
anotherImageIn2=iter2.hasNext();
}
std::complex<double> qu[4], qt[4], M[4], Inv_qu[4], test[4], P1[4], P2[4], Inv_quu[4];
double rotu=34*PI/180, tiltu=10*PI/180, psiu=5*PI/180;
double rott=25*PI/180, tiltt=15*PI/180, psit=40*PI/180;
quaternion2Paulibasis(rotu, tiltu, psiu, qu);
/*std::cout << "quaternion2Pauli" << std::endl;
std::cout << "Untilted " << qu[0] << " " << qu[1] << " " << qu[2] << " " << qu[3] << std::endl;
std::cout << " " << std::endl;*/
Paulibasis2matrix(qu,M);
/*std::cout << "Pauli2matrix" << std::endl;
std::cout << "Matriz " << M[0] << " " << M[1] << " " << M[2] << " " << M[3] << std::endl;
std::cout << " " << std::endl;*/
inverse_matrixSU2(M, Inv_qu);
/*std::cout << "inverse_matrixSU(2)" << std::endl;
std::cout << "Inversa " << Inv_qu[0] << " " << Inv_qu[1] << " " << Inv_qu[2] << " " << Inv_qu[3] << std::endl;
std::cout << " " << std::endl;*/
quaternion2Paulibasis(rott, tiltt, psit, qt);
/*std::cout << "quaternion2Pauli" << std::endl;
std::cout << "Tilted " << qt[0] << " " << qt[1] << " " << qt[2] << " " << qt[3] << std::endl;
std::cout << " " << std::endl;*/
InversefromPaulibasis(qu,Inv_quu);
Pauliproduct(qt, Inv_qu, P1);
/*std::cout << "Pauliproduct" << std::endl;
std::cout << "quaternion qt " << P1[0] << " " << P1[1] << " " << P1[2] << " " << P1[3] << std::endl;
std::cout << " " << std::endl;
std::cout << "-----------------------------------" << std::endl;*/
//double alpha_x, alpha_y;
//extrarotationangles(P1, alpha_x, alpha_y);
//std::cout << "alpha_x = " << alpha_x << " " << "alpha_y = " << alpha_y << std::endl;
}
void
computeConsistentRotations_Linf(double const sigma, int const nIterations, int const nViews,
std::vector<Matrix3x3d> const& relativeRotations,
std::vector<std::pair<int, int> > const& viewPairs,
std::vector<Matrix3x3d>& rotations, std::vector<double>& zs)
{
double const gamma = 1.0;
int const nRelPoses = relativeRotations.size();
rotations.resize(nViews);
Matrix3x3d zero3x3d;
makeZeroMatrix(zero3x3d);
Matrix4x4d zeroQuat;
makeZeroMatrix(zeroQuat); zeroQuat[0][0] = 1;
double const denomT = 1.0 / (1.0 + nRelPoses);
vector<double> denomQ(nViews, 1.0); // from the psd constraint
for (int k = 0; k < nRelPoses; ++k)
{
int const i = viewPairs[k].first;
int const j = viewPairs[k].second;
denomQ[i] += 1;
denomQ[j] += 1;
}
for (int i = 0; i < nViews; ++i) denomQ[i] = 1.0 / denomQ[i];
double T = 0.0;
vector<double> T1(nRelPoses);
vector<double> ZT1(nRelPoses, 0.0);
double T2;
double ZT2 = 0;
vector<Matrix4x4d> Q(nViews, zeroQuat);
vector<Matrix4x4d> Q1(nViews, zeroQuat);
vector<Matrix4x4d> ZQ1(nViews, zeroQuat);
vector<Matrix4x4d> Q2i(nRelPoses, zeroQuat);
vector<Matrix4x4d> Q2j(nRelPoses, zeroQuat);
vector<Matrix4x4d> ZQ2i(nRelPoses, zeroQuat);
vector<Matrix4x4d> ZQ2j(nRelPoses, zeroQuat);
vector<Matrix3x3d> A(nRelPoses, zero3x3d);
vector<Matrix3x3d> A1(nRelPoses, zero3x3d);
vector<Matrix3x3d> A2(nRelPoses, zero3x3d);
vector<Matrix3x3d> ZA1(nRelPoses, zero3x3d);
vector<Matrix3x3d> ZA2(nRelPoses, zero3x3d);
for (int iter = 0; iter < nIterations; ++iter)
{
// Convex hull of rotation matrices
for (int i = 0; i < nViews; ++i)
{
Matrix4x4d q = Q[i] + ZQ1[i];
if (i > 0)
projectConvHull_SO3(q);
else
{
makeZeroMatrix(q);
q[0][0] = 1;
}
Q1[i] = q;
addMatricesIP(Q[i] - q, ZQ1[i]);
} // end for (i)
// Shrinkage of T (we want to minimize T)
T2 = std::max(0.0, T + ZT2 - gamma);
ZT2 += T - T2;
// Cone constraint
for (int k = 0; k < nRelPoses; ++k)
{
double t = T + ZT1[k];
Matrix3x3d a = A[k] + ZA1[k];
proxDataResidual_Frobenius(sigma, t, a);
T1[k] = t;
ZT1[k] += T - t;
A1[k] = a;
addMatricesIP(A[k] - a, ZA1[k]);
} // end for (k)
// Enforce linear consistency
for (int k = 0; k < nRelPoses; ++k)
{
int const i = viewPairs[k].first;
int const j = viewPairs[k].second;
Matrix4x4d qi = Q[i] + ZQ2i[k];
Matrix4x4d qj = Q[j] + ZQ2j[k];
Matrix3x3d a = A[k] + ZA2[k];
proxConsistency(relativeRotations[k], qi, qj, a);
Q2i[k] = qi;
Q2j[k] = qj;
A2[k] = a;
addMatricesIP(Q[i] - qi, ZQ2i[k]);
addMatricesIP(Q[j] - qj, ZQ2j[k]);
addMatricesIP(A[k] - a, ZA2[k]);
} // end for (k)
// Averaging of the solutions
for (int i = 0; i < nViews; ++i) Q[i] = Q1[i] - ZQ1[i];
T = T2 - ZT2;
for (int k = 0; k < nRelPoses; ++k) T += T1[k] - ZT1[k];
T *= denomT;
T = std::max(0.0, T);
for (int k = 0; k < nRelPoses; ++k) A[k] = A1[k] - ZA1[k];
for (int k = 0; k < nRelPoses; ++k)
{
int const i = viewPairs[k].first;
int const j = viewPairs[k].second;
addMatricesIP(Q2i[k] - ZQ2i[k], Q[i]);
addMatricesIP(Q2j[k] - ZQ2j[k], Q[j]);
addMatricesIP(A2[k] - ZA2[k], A[k]);
} // end for (k)
for (int i = 0; i < nViews; ++i) scaleMatrixIP(denomQ[i], Q[i]);
for (int k = 0; k < nRelPoses; ++k) scaleMatrixIP(0.5, A[k]);
if ((iter % 500) == 0)
{
cout << "iter: " << iter << " t = " << T << endl;
cout << "T1 = "; displayVector(T1);
cout << "ZT1 = "; displayVector(ZT1);
cout << "T2 = " << T2 << " ZT2 = " << ZT2 << endl;
Matrix<double> ZZ(4, 4);
for (int i = 0; i < nViews; ++i)
{
copyMatrix(Q[i], ZZ);
SVD<double> svd(ZZ);
cout << "Q = "; displayMatrix(ZZ);
cout << "SV = "; displayVector(svd.getSingularValues());
//Matrix3x3d R = getRotationFromQuat(Q[i]);
//cout << "R = "; displayMatrix(R);
} // end for (i)
}
} // end for (iter)
rotations.resize(nViews);
for (int i = 0; i < nViews; ++i)
rotations[i] = getRotationFromQuat(Q[i]);
zs = ZT1;
} // end computeConsistentRotations_Linf()
int main()
{
setbuf(stdout, NULL);
SetSeed(ZZ(0));
for (long l = 256; l <= 16384; l *= 2) {
// for (long n = 256; n <= 16384; n *= 2) {
for (long idx = 0; idx < 13; idx ++) {
long n = 256*(1L << idx/2);
if (idx & 1) n += n/2;
SetSeed((ZZ(l) << 64) + ZZ(n));
ZZ p;
RandomLen(p, l);
if (!IsOdd(p)) p++;
ZZ_p::init(p);
ZZ_pX a, c, f;
random(a, n);
random(f, n);
SetCoeff(f, n);
ZZ_pXModulus F(f);
double t;
SqrMod(c, a, F);
long iter = 1;
do {
t = GetTime();
for (long i = 0; i < iter; i++) SqrMod(c, a, F);
t = GetTime() - t;
iter *= 2;
} while (t < 3);
iter /= 2;
t = GetTime();
for (long i = 0; i < iter; i++) SqrMod(c, a, F);
t = GetTime()-t;
double NTLTime = t;
FlintZZ_pX f_a(a), f_c, f_f(f), f_finv;
fmpz_mod_poly_reverse(f_finv.value, f_f.value, f_f.value->length);
fmpz_mod_poly_inv_series_newton(f_finv.value, f_finv.value, f_f.value->length);
fmpz_mod_poly_mulmod_preinv(f_c.value, f_a.value, f_a.value, f_f.value, f_finv.value);
t = GetTime();
for (long i = 0; i < iter; i++)
fmpz_mod_poly_mulmod_preinv(f_c.value, f_a.value, f_a.value, f_f.value, f_finv.value);
t = GetTime()-t;
double FlintTime = t;
printf("%8.2f", FlintTime/NTLTime);
}
printf("\n");
}
}
//#define DEBUG
void spatial_Bspline032voxels(const GridVolume &vol_splines,
MultidimArray<double> *vol_voxels, int Zdim, int Ydim, int Xdim)
{
// Resize and set starting corner .......................................
if (Zdim == 0 || Ydim == 0 || Xdim == 0)
{
Matrix1D<double> size = vol_splines.grid(0).highest -
vol_splines.grid(0).lowest;
Matrix1D<double> corner = vol_splines.grid(0).lowest;
(*vol_voxels).initZeros(CEIL(ZZ(size)), CEIL(YY(size)), CEIL(XX(size)));
STARTINGX(*vol_voxels) = FLOOR(XX(corner));
STARTINGY(*vol_voxels) = FLOOR(YY(corner));
STARTINGZ(*vol_voxels) = FLOOR(ZZ(corner));
}
else
{
(*vol_voxels).initZeros(Zdim, Ydim, Xdim);
(*vol_voxels).setXmippOrigin();
}
// Convert each subvolume ...............................................
for (size_t i = 0; i < vol_splines.VolumesNo(); i++)
{
spatial_Bspline032voxels_SimpleGrid(vol_splines(i)(), vol_splines.grid(i),
vol_voxels);
#ifdef DEBUG
std::cout << "Spline grid no " << i << " stats: ";
vol_splines(i)().printStats();
std::cout << std::endl;
std::cout << "So far vol stats: ";
(*vol_voxels).printStats();
std::cout << std::endl;
VolumeXmipp save;
save() = *vol_voxels;
save.write((std::string)"PPPvoxels" + integerToString(i));
#endif
}
// Now normalise the resulting volume ..................................
double inorm = 1.0 / sum_spatial_Bspline03_Grid(vol_splines.grid());
FOR_ALL_ELEMENTS_IN_ARRAY3D(*vol_voxels)
A3D_ELEM(*vol_voxels, k, i, j) *= inorm;
// Set voxels outside interest region to minimum value .................
double R = vol_splines.grid(0).get_interest_radius();
if (R != -1)
{
double R2 = (R - 6) * (R - 6);
// Compute minimum value within sphere
double min_val = A3D_ELEM(*vol_voxels, 0, 0, 0);
FOR_ALL_ELEMENTS_IN_ARRAY3D(*vol_voxels)
if (j*j + i*i + k*k <= R2 - 4)
min_val = XMIPP_MIN(min_val, A3D_ELEM(*vol_voxels, k, i, j));
// Substitute minimum value
R2 = (R - 2) * (R - 2);
FOR_ALL_ELEMENTS_IN_ARRAY3D(*vol_voxels)
if (j*j + i*i + k*k >= R2)
A3D_ELEM(*vol_voxels, k, i, j) = min_val;
}
/* Splines -> Voxels for a SimpleGrid -------------------------------------- */
void spatial_Bspline032voxels_SimpleGrid(const MultidimArray<double> &vol_splines,
const SimpleGrid &grid,
MultidimArray<double> *vol_voxels,
const MultidimArray<double> *vol_mask = NULL)
{
Matrix1D<double> act_coord(3); // Coord: Actual position inside
// the voxel volume without deforming
Matrix1D<double> beginZ(3); // Coord: Voxel coordinates of the
// blob at the 3D point
// (z0,YY(lowest),XX(lowest))
Matrix1D<double> beginY(3); // Coord: Voxel coordinates of the
// blob at the 3D point
// (z0,y0,XX(lowest))
Matrix1D<double> corner2(3), corner1(3); // Coord: Corners of the
// blob in the voxel volume
Matrix1D<double> gcurrent(3); // Position in g of current point
double intx, inty, intz; // Nearest integer voxel
int i, j, k; // Index within the blob volume
bool process; // True if this blob has to be
// processed
double spline_radius = 2 * sqrt(3.0);
// Some aliases
#define x0 STARTINGX(*vol_voxels)
#define xF FINISHINGX(*vol_voxels)
#define y0 STARTINGY(*vol_voxels)
#define yF FINISHINGY(*vol_voxels)
#define z0 STARTINGZ(*vol_voxels)
#define zF FINISHINGZ(*vol_voxels)
#ifdef DEBUG
bool condition = true;
(*vol_voxels)().printShape();
std::cout << std::endl;
std::cout << "x0= " << x0 << " xF= " << xF << std::endl;
std::cout << "y0= " << y0 << " yF= " << yF << std::endl;
std::cout << "z0= " << z0 << " zF= " << zF << std::endl;
std::cout << grid;
#endif
// Convert the whole grid ...............................................
// Corner of the plane defined by Z. These coordinates are in the
// universal coord. system
grid.grid2universe(grid.lowest, beginZ);
Matrix1D<double> grid_index(3);
for (k = (int) ZZ(grid.lowest); k <= (int) ZZ(grid.highest); k++)
{
// Corner of the row defined by Y
beginY = beginZ;
for (i = (int) YY(grid.lowest); i <= (int) YY(grid.highest); i++)
{
// First point in the row
act_coord = beginY;
for (j = (int) XX(grid.lowest); j <= (int) XX(grid.highest); j++)
{
VECTOR_R3(grid_index, j, i, k);
#ifdef DEBUG
if (condition)
{
printf("Dealing spline at (%d,%d,%d) = %f\n", j, i, k, A3D_ELEM(vol_splines, k, i, j));
std::cout << "Center of the blob "
<< act_coord.transpose() << std::endl;
}
#endif
// These two corners are also real valued
process = true;
if (XX(act_coord) >= xF) process = false;
if (YY(act_coord) >= yF) process = false;
if (ZZ(act_coord) >= zF) process = false;
if (XX(act_coord) <= x0) process = false;
if (YY(act_coord) <= y0) process = false;
if (ZZ(act_coord) <= z0) process = false;
#ifdef DEBUG
if (!process && condition) std::cout << " It is outside output volume\n";
#endif
if (!grid.is_interesting(act_coord))
{
#ifdef DEBUG
if (process && condition) std::cout << " It is not interesting\n";
#endif
process = false;
}
if (process)
{
V3_PLUS_CT(corner1, act_coord, -spline_radius);
V3_PLUS_CT(corner2, act_coord, spline_radius);
#ifdef DEBUG
if (condition)
{
std::cout << "Corner 1 for this point " << corner1.transpose() << std::endl;
std::cout << "Corner 2 for this point " << corner2.transpose() << std::endl;
}
#endif
// Clip the corners to the volume borders
XX(corner1) = ROUND(CLIP(XX(corner1), x0, xF));
YY(corner1) = ROUND(CLIP(YY(corner1), y0, yF));
ZZ(corner1) = ROUND(CLIP(ZZ(corner1), z0, zF));
XX(corner2) = ROUND(CLIP(XX(corner2), x0, xF));
YY(corner2) = ROUND(CLIP(YY(corner2), y0, yF));
ZZ(corner2) = ROUND(CLIP(ZZ(corner2), z0, zF));
#ifdef DEBUG
if (condition)
{
std::cout << "Clipped and rounded Corner 1 " << corner1.transpose() << std::endl;
std::cout << "Clipped and rounded Corner 2 " << corner2.transpose() << std::endl;
}
#endif
// Effectively convert
for (intz = ZZ(corner1); intz <= ZZ(corner2); intz++)
for (inty = YY(corner1); inty <= YY(corner2); inty++)
for (intx = XX(corner1); intx <= XX(corner2); intx++)
{
int iz = (int)intz, iy = (int)inty, ix = (int)intx;
if (vol_mask != NULL)
if (!A3D_ELEM(*vol_mask, iz, iy, ix)) continue;
// Compute the spline value at this point
VECTOR_R3(gcurrent, intx, inty, intz);
V3_MINUS_V3(gcurrent, act_coord, gcurrent);
double spline_value = spatial_Bspline03(gcurrent);
#ifdef DEBUG_MORE
if (condition)
{
std::cout << "At (" << intx << ","
<< inty << "," << intz << ") value="
<< spline_value;
std::cout.flush();
}
#endif
// Add at that position the corresponding spline value
A3D_ELEM(*vol_voxels, iz, iy, ix) +=
A3D_ELEM(vol_splines, k, i, j) * spline_value;
#ifdef DEBUG_MORE
if (condition)
{
std::cout << " adding " << A3D_ELEM(vol_splines, k, i, j)
<< " * " << value_spline << " = "
<< A3D_ELEM(vol_splines, k, i, j)*
value_spline << std::endl;
std::cout.flush();
}
#endif
}
}
// Prepare for next iteration
XX(act_coord) = XX(act_coord) + grid.relative_size * grid.basis(0, 0);
YY(act_coord) = YY(act_coord) + grid.relative_size * grid.basis(1, 0);
ZZ(act_coord) = ZZ(act_coord) + grid.relative_size * grid.basis(2, 0);
}
XX(beginY) = XX(beginY) + grid.relative_size * grid.basis(0, 1);
YY(beginY) = YY(beginY) + grid.relative_size * grid.basis(1, 1);
ZZ(beginY) = ZZ(beginY) + grid.relative_size * grid.basis(2, 1);
}
XX(beginZ) = XX(beginZ) + grid.relative_size * grid.basis(0, 2);
YY(beginZ) = YY(beginZ) + grid.relative_size * grid.basis(1, 2);
ZZ(beginZ) = ZZ(beginZ) + grid.relative_size * grid.basis(2, 2);
}
}
//#define DEBUG
double spatial_Bspline03_proj(
const Matrix1D<double> &r, const Matrix1D<double> &u)
{
// Avoids divisions by zero and allows orthogonal rays computation
static Matrix1D<double> ur(3);
if (XX(u) == 0) XX(ur) = XMIPP_EQUAL_ACCURACY;
else XX(ur) = XX(u);
if (YY(u) == 0) YY(ur) = XMIPP_EQUAL_ACCURACY;
else YY(ur) = YY(u);
if (ZZ(u) == 0) ZZ(ur) = XMIPP_EQUAL_ACCURACY;
else ZZ(ur) = ZZ(u);
// Some precalculated variables
double x_sign = SGN(XX(ur));
double y_sign = SGN(YY(ur));
double z_sign = SGN(ZZ(ur));
// Compute the minimum and maximum alpha for the ray
double alpha_xmin = (-2 - XX(r)) / XX(ur);
double alpha_xmax = (2 - XX(r)) / XX(ur);
double alpha_ymin = (-2 - YY(r)) / YY(ur);
double alpha_ymax = (2 - YY(r)) / YY(ur);
double alpha_zmin = (-2 - ZZ(r)) / ZZ(ur);
double alpha_zmax = (2 - ZZ(r)) / ZZ(ur);
double alpha_min = XMIPP_MAX(XMIPP_MIN(alpha_xmin, alpha_xmax),
XMIPP_MIN(alpha_ymin, alpha_ymax));
alpha_min = XMIPP_MAX(alpha_min, XMIPP_MIN(alpha_zmin, alpha_zmax));
double alpha_max = XMIPP_MIN(XMIPP_MAX(alpha_xmin, alpha_xmax),
XMIPP_MAX(alpha_ymin, alpha_ymax));
alpha_max = XMIPP_MIN(alpha_max, XMIPP_MAX(alpha_zmin, alpha_zmax));
if (alpha_max - alpha_min < XMIPP_EQUAL_ACCURACY) return 0.0;
#ifdef DEBUG
std::cout << "Pixel: " << r.transpose() << std::endl
<< "Dir: " << ur.transpose() << std::endl
<< "Alpha x:" << alpha_xmin << " " << alpha_xmax << std::endl
<< " " << (r + alpha_xmin*ur).transpose() << std::endl
<< " " << (r + alpha_xmax*ur).transpose() << std::endl
<< "Alpha y:" << alpha_ymin << " " << alpha_ymax << std::endl
<< " " << (r + alpha_ymin*ur).transpose() << std::endl
<< " " << (r + alpha_ymax*ur).transpose() << std::endl
<< "Alpha z:" << alpha_zmin << " " << alpha_zmax << std::endl
<< " " << (r + alpha_zmin*ur).transpose() << std::endl
<< " " << (r + alpha_zmax*ur).transpose() << std::endl
<< "alpha :" << alpha_min << " " << alpha_max << std::endl
<< std::endl;
#endif
// Compute the first point in the volume intersecting the ray
static Matrix1D<double> v(3);
V3_BY_CT(v, ur, alpha_min);
V3_PLUS_V3(v, r, v);
#ifdef DEBUG
std::cout << "First entry point: " << v.transpose() << std::endl;
std::cout << " Alpha_min: " << alpha_min << std::endl;
#endif
// Follow the ray
double alpha = alpha_min;
double ray_sum = 0;
do
{
double alpha_x = (XX(v) + x_sign - XX(r)) / XX(ur);
double alpha_y = (YY(v) + y_sign - YY(r)) / YY(ur);
double alpha_z = (ZZ(v) + z_sign - ZZ(r)) / ZZ(ur);
// Which dimension will ray move next step into?, it isn't neccesary to be only
// one.
double diffx = ABS(alpha - alpha_x);
double diffy = ABS(alpha - alpha_y);
double diffz = ABS(alpha - alpha_z);
double diff_alpha = XMIPP_MIN(XMIPP_MIN(diffx, diffy), diffz);
ray_sum += spatial_Bspline03_integral(r, ur, alpha, alpha + diff_alpha);
// Update alpha and the next entry point
if (ABS(diff_alpha - diffx) <= XMIPP_EQUAL_ACCURACY) alpha = alpha_x;
if (ABS(diff_alpha - diffy) <= XMIPP_EQUAL_ACCURACY) alpha = alpha_y;
if (ABS(diff_alpha - diffz) <= XMIPP_EQUAL_ACCURACY) alpha = alpha_z;
XX(v) += diff_alpha * XX(ur);
YY(v) += diff_alpha * YY(ur);
ZZ(v) += diff_alpha * ZZ(ur);
#ifdef DEBUG
std::cout << "Alpha x,y,z: " << alpha_x << " " << alpha_y
<< " " << alpha_z << " ---> " << alpha << std::endl;
std::cout << " Next entry point: " << v.transpose() << std::endl
<< " diff_alpha: " << diff_alpha << std::endl
<< " ray_sum: " << ray_sum << std::endl
<< " Alfa tot: " << alpha << "alpha_max: " << alpha_max <<
std::endl;
#endif
}
while ((alpha_max - alpha) > XMIPP_EQUAL_ACCURACY);
return ray_sum;
}
