Real ArithmeticAveragedOvernightIndexedCouponPricer::convAdj1(Time ts, Time te) const {
Real vol = vol_->value();
Real k = meanReversion_->value();
return vol * vol / ( 4.0 * pow(k, 3.0) ) * ( 1.0 - exp(-2.0*k*ts)) * pow(( 1.0 - exp(-k*(te-ts)) ), 2.0);
}
SEXP jmoy_gradient(SEXP handle,SEXP sbeta,SEXP salpha){
Data *data;
SEXP sgrad;
double *beta;
double alpha;
double *grad;
int i,j;
data=R_ExternalPtrAddr(handle);
beta=REAL(sbeta);
alpha=REAL(salpha)[0];
PROTECT(sgrad=allocVector(REALSXP,data->nvars+1));
grad=REAL(sgrad);
for(i=0;i<data->nvars+1;i++)
grad[i]=0;
/*Uncensored observations*/
for(i=0;i<data->uc_nobs;i++){
double xbeta=0.0;
double t=data->uc_y[i];
double t_alpha=pow(t,alpha);
double exp_xbeta;
double grad_xbeta;
for(j=0;j<data->nvars;j++)
xbeta+=data->uc_x[i+j*data->uc_nobs]*beta[j];
exp_xbeta=exp(xbeta);
grad_xbeta=1.0-exp_xbeta*t_alpha;
for (j=0;j<data->nvars;j++)
grad[j]-=data->uc_x[i+j*data->uc_nobs]*grad_xbeta;
grad[data->nvars]-=
1.0/alpha
+(1.0-exp_xbeta*t_alpha)*log(t);
}
/*Censored observations*/
for(i=0;i<data->c_nobs;i++){
double xbeta=0.0;
double t=data->c_y[i];
double t_alpha=pow(t,alpha);
double exp_xbeta;
double grad_xbeta;
for(j=0;j<data->nvars;j++)
xbeta+=data->c_x[i+j*data->c_nobs]*beta[j];
exp_xbeta=exp(xbeta);
grad_xbeta=-exp_xbeta*t_alpha;
for (j=0;j<data->nvars;j++)
grad[j]-=data->c_x[i+j*data->c_nobs]*grad_xbeta;
grad[data->nvars]-=-exp_xbeta*t_alpha*log(t);
}
UNPROTECT(1); /*sgrad*/
return sgrad;
}
void ScatterSky::_getColor( const Point3F &pos, ColorF *outColor )
{
PROFILE_SCOPE( ScatterSky_GetColor );
F32 scaleOverScaleDepth = mScale / mRayleighScaleDepth;
F32 rayleighBrightness = mRayleighScattering * mSkyBrightness;
F32 mieBrightness = mMieScattering * mSkyBrightness;
Point3F invWaveLength( 1.0f / mWavelength4[0],
1.0f / mWavelength4[1],
1.0f / mWavelength4[2] );
Point3F v3Pos = pos / 6378000.0f;
v3Pos.z += mSphereInnerRadius;
Point3F newCamPos( 0, 0, smViewerHeight );
VectorF v3Ray = v3Pos - newCamPos;
F32 fFar = v3Ray.len();
v3Ray / fFar;
v3Ray.normalizeSafe();
Point3F v3Start = newCamPos;
F32 fDepth = mExp( scaleOverScaleDepth * (mSphereInnerRadius - smViewerHeight ) );
F32 fStartAngle = mDot( v3Ray, v3Start );
F32 fStartOffset = fDepth * _vernierScale( fStartAngle );
F32 fSampleLength = fFar / 2.0f;
F32 fScaledLength = fSampleLength * mScale;
VectorF v3SampleRay = v3Ray * fSampleLength;
Point3F v3SamplePoint = v3Start + v3SampleRay * 0.5f;
Point3F v3FrontColor( 0, 0, 0 );
for ( U32 i = 0; i < 2; i++ )
{
F32 fHeight = v3SamplePoint.len();
F32 fDepth = mExp( scaleOverScaleDepth * (mSphereInnerRadius - smViewerHeight) );
F32 fLightAngle = mDot( mLightDir, v3SamplePoint ) / fHeight;
F32 fCameraAngle = mDot( v3Ray, v3SamplePoint ) / fHeight;
F32 fScatter = (fStartOffset + fDepth * ( _vernierScale( fLightAngle ) - _vernierScale( fCameraAngle ) ));
Point3F v3Attenuate( 0, 0, 0 );
F32 tmp = mExp( -fScatter * (invWaveLength[0] * mRayleighScattering4PI + mMieScattering4PI) );
v3Attenuate.x = tmp;
tmp = mExp( -fScatter * (invWaveLength[1] * mRayleighScattering4PI + mMieScattering4PI) );
v3Attenuate.y = tmp;
tmp = mExp( -fScatter * (invWaveLength[2] * mRayleighScattering4PI + mMieScattering4PI) );
v3Attenuate.z = tmp;
v3FrontColor += v3Attenuate * (fDepth * fScaledLength);
v3SamplePoint += v3SampleRay;
}
Point3F mieColor = v3FrontColor * mieBrightness;
Point3F rayleighColor = v3FrontColor * (invWaveLength * rayleighBrightness);
Point3F v3Direction = newCamPos - v3Pos;
v3Direction.normalize();
F32 fCos = mDot( mLightDir, v3Direction ) / v3Direction.len();
F32 fCos2 = fCos * fCos;
F32 g = -0.991f;
F32 g2 = g * g;
F32 miePhase = _getMiePhase( fCos, fCos2, g, g2 );
Point3F color = rayleighColor + (miePhase * mieColor);
ColorF tmp( color.x, color.y, color.z, color.y );
Point3F expColor( 0, 0, 0 );
expColor.x = 1.0f - exp(-mExposure * color.x);
expColor.y = 1.0f - exp(-mExposure * color.y);
expColor.z = 1.0f - exp(-mExposure * color.z);
tmp.set( expColor.x, expColor.y, expColor.z, 1.0f );
if ( !tmp.isValidColor() )
{
F32 len = expColor.len();
if ( len > 0 )
expColor /= len;
}
outColor->set( expColor.x, expColor.y, expColor.z, 1.0f );
}
double Xsec_Fusion_NRL(double& Energy)// Energy in in Joules, and energy is collision energy
{
if(Energy==0)
{
return 0;
}
else
{
int id_p = 1; // 'Incident' deuteron
int id_b = 2; // 'Target' triton
double E_in = (Energy/(1.0E3*e_ch))*(mass[id_p]+mass[id_b])/mass[id_b]; // Convert from J to keV, and to energy of a deuteron incident on a triton
double xsec = (Fuse_coefs_NRL[5]+Fuse_coefs_NRL[2]/(pow(Fuse_coefs_NRL[4]-Fuse_coefs_NRL[3]*E_in,2)+1.0E0))/(E_in*(exp(Fuse_coefs_NRL[1]/sqrt(E_in))-1.0E0));
return xsec*1.0E-28; // Convert from barns to m^-2
}
}
void evaluation()
{
QFETCH( QString, string );
QFETCH( bool, evalError );
QFETCH( QVariant, result );
QgsExpression exp( string );
QCOMPARE( exp.hasParserError(), false );
if ( exp.hasParserError() )
qDebug() << exp.parserErrorString();
QVariant res = exp.evaluate();
if ( exp.hasEvalError() )
qDebug() << exp.evalErrorString();
if ( res.type() != result.type() )
{
qDebug() << "got " << res.typeName() << " instead of " << result.typeName();
}
//qDebug() << res.type() << " " << result.type();
//qDebug() << "type " << res.typeName();
QCOMPARE( exp.hasEvalError(), evalError );
QCOMPARE( res.type(), result.type() );
switch ( res.type() )
{
case QVariant::Invalid:
break; // nothing more to check
case QVariant::Int:
QCOMPARE( res.toInt(), result.toInt() );
break;
case QVariant::Double:
QCOMPARE( res.toDouble(), result.toDouble() );
break;
case QVariant::String:
QCOMPARE( res.toString(), result.toString() );
break;
case QVariant::Date:
QCOMPARE( res.toDate(), result.toDate() );
break;
case QVariant::DateTime:
QCOMPARE( res.toDateTime(), result.toDateTime() );
break;
case QVariant::Time:
QCOMPARE( res.toTime(), result.toTime() );
break;
case QVariant::UserType:
{
if ( res.userType() == qMetaTypeId<QgsExpression::Interval>() )
{
QgsExpression::Interval inter = res.value<QgsExpression::Interval>();
QgsExpression::Interval gotinter = result.value<QgsExpression::Interval>();
QCOMPARE( inter.seconds(), gotinter.seconds() );
}
else
{
QFAIL( "unexpected user type" );
}
break;
}
default:
Q_ASSERT( false ); // should never happen
}
}
//the gaussian function
double
gauss (double x, double x_0, double mysigma)
{
return exp (-0.5 * (x - x_0) * (x - x_0) / mysigma / mysigma);
}
float Exp(float fValue)
{
return static_cast<float>(exp(fValue));
}
//==========================================================================
//
//
//
//==========================================================================
void GLSprite::Draw(int pass)
{
if (pass!=GLPASS_PLAIN && pass != GLPASS_ALL && pass!=GLPASS_TRANSLUCENT) return;
// Hack to enable bright sprites in faded maps
uint32 backupfade = Colormap.FadeColor.d;
if (gl_spritebrightfog && fullbright)
Colormap.FadeColor = 0;
bool additivefog = false;
int rel = extralight*gl_weaponlight;
if (pass==GLPASS_TRANSLUCENT)
{
// The translucent pass requires special setup for the various modes.
// Brightmaps will only be used when doing regular drawing ops and having no fog
if (!gl_spritebrightfog && (!gl_isBlack(Colormap.FadeColor) || level.flags&LEVEL_HASFADETABLE ||
RenderStyle.BlendOp != STYLEOP_Add))
{
gl_RenderState.EnableBrightmap(false);
}
gl_SetRenderStyle(RenderStyle, false,
// The rest of the needed checks are done inside gl_SetRenderStyle
trans > 1.f - FLT_EPSILON && gl_usecolorblending && gl_fixedcolormap < CM_FIRSTSPECIALCOLORMAP && actor &&
fullbright && gltexture && !gltexture->GetTransparent());
if (hw_styleflags == STYLEHW_NoAlphaTest)
{
gl_RenderState.EnableAlphaTest(false);
}
else
{
gl_RenderState.AlphaFunc(GL_GEQUAL,trans*gl_mask_sprite_threshold);
}
if (RenderStyle.BlendOp == STYLEOP_Fuzz)
{
float fuzzalpha=0.44f;
float minalpha=0.1f;
// fog + fuzz don't work well without some fiddling with the alpha value!
if (!gl_isBlack(Colormap.FadeColor))
{
float xcamera=FIXED2FLOAT(viewx);
float ycamera=FIXED2FLOAT(viewy);
float dist=Dist2(xcamera,ycamera, x,y);
if (!Colormap.FadeColor.a) Colormap.FadeColor.a=clamp<int>(255-lightlevel,60,255);
// this value was determined by trial and error and is scale dependent!
float factor=0.05f+exp(-Colormap.FadeColor.a*dist/62500.f);
fuzzalpha*=factor;
minalpha*=factor;
}
gl_RenderState.AlphaFunc(GL_GEQUAL,minalpha*gl_mask_sprite_threshold);
gl.Color4f(0.2f,0.2f,0.2f,fuzzalpha);
additivefog = true;
}
else if (RenderStyle.BlendOp == STYLEOP_Add && RenderStyle.DestAlpha == STYLEALPHA_One)
{
additivefog = true;
}
}
if (RenderStyle.BlendOp!=STYLEOP_Fuzz)
{
if (actor)
{
lightlevel = gl_SetSpriteLighting(RenderStyle, actor, lightlevel, rel, &Colormap, ThingColor, trans,
fullbright || gl_fixedcolormap >= CM_FIRSTSPECIALCOLORMAP, false);
}
else if (particle)
{
if (gl_light_particles)
{
lightlevel = gl_SetSpriteLight(particle, lightlevel, rel, &Colormap, trans, ThingColor);
}
else
{
gl_SetColor(lightlevel, rel, &Colormap, trans, ThingColor);
}
}
else return;
}
if (gl_isBlack(Colormap.FadeColor)) foglevel=lightlevel;
if (RenderStyle.Flags & STYLEF_FadeToBlack)
{
Colormap.FadeColor=0;
additivefog = true;
}
if (RenderStyle.Flags & STYLEF_InvertOverlay)
{
Colormap.FadeColor = Colormap.FadeColor.InverseColor();
additivefog=false;
}
gl_SetFog(foglevel, rel, &Colormap, additivefog);
if (gltexture) gltexture->BindPatch(Colormap.colormap,translation);
else if (!modelframe) gl_RenderState.EnableTexture(false);
if (!modelframe)
{
// [BB] Billboard stuff
const bool drawWithXYBillboard = ( !(actor && actor->renderflags & RF_FORCEYBILLBOARD)
//&& GLRenderer->mViewActor != NULL
&& (gl_billboard_mode == 1 || (actor && actor->renderflags & RF_FORCEXYBILLBOARD )) );
gl_RenderState.Apply();
gl.Begin(GL_TRIANGLE_STRIP);
if ( drawWithXYBillboard )
{
// Rotate the sprite about the vector starting at the center of the sprite
// triangle strip and with direction orthogonal to where the player is looking
// in the x/y plane.
float xcenter = (x1+x2)*0.5;
float ycenter = (y1+y2)*0.5;
float zcenter = (z1+z2)*0.5;
float angleRad = DEG2RAD(270. - float(GLRenderer->mAngles.Yaw));
Matrix3x4 mat;
mat.MakeIdentity();
mat.Translate( xcenter, zcenter, ycenter);
mat.Rotate(-sin(angleRad), 0, cos(angleRad), -GLRenderer->mAngles.Pitch);
mat.Translate( -xcenter, -zcenter, -ycenter);
Vector v1 = mat * Vector(x1,z1,y1);
Vector v2 = mat * Vector(x2,z1,y2);
Vector v3 = mat * Vector(x1,z2,y1);
Vector v4 = mat * Vector(x2,z2,y2);
if (gltexture)
{
gl.TexCoord2f(ul, vt); gl.Vertex3fv(&v1[0]);
gl.TexCoord2f(ur, vt); gl.Vertex3fv(&v2[0]);
gl.TexCoord2f(ul, vb); gl.Vertex3fv(&v3[0]);
gl.TexCoord2f(ur, vb); gl.Vertex3fv(&v4[0]);
}
else // Particle
{
gl.Vertex3fv(&v1[0]);
gl.Vertex3fv(&v2[0]);
gl.Vertex3fv(&v3[0]);
gl.Vertex3fv(&v4[0]);
}
}
else
{
if (gltexture)
{
gl.TexCoord2f(ul, vt); gl.Vertex3f(x1, z1, y1);
gl.TexCoord2f(ur, vt); gl.Vertex3f(x2, z1, y2);
gl.TexCoord2f(ul, vb); gl.Vertex3f(x1, z2, y1);
gl.TexCoord2f(ur, vb); gl.Vertex3f(x2, z2, y2);
}
else // Particle
{
gl.Vertex3f(x1, z1, y1);
gl.Vertex3f(x2, z1, y2);
gl.Vertex3f(x1, z2, y1);
gl.Vertex3f(x2, z2, y2);
}
}
gl.End();
}
else
{
gl_RenderModel(this, Colormap.colormap);
}
if (pass==GLPASS_TRANSLUCENT)
{
gl_RenderState.EnableBrightmap(true);
gl_RenderState.BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
gl_RenderState.BlendEquation(GL_FUNC_ADD);
gl_RenderState.SetTextureMode(TM_MODULATE);
// [BB] Restore the alpha test after drawing a smooth particle.
if (hw_styleflags == STYLEHW_NoAlphaTest)
{
gl_RenderState.EnableAlphaTest(true);
}
else
{
gl_RenderState.AlphaFunc(GL_GEQUAL,gl_mask_sprite_threshold);
}
}
// End of gl_sprite_brightfog hack: restore FadeColor to normalcy
if (backupfade != Colormap.FadeColor.d)
Colormap.FadeColor = backupfade;
gl_RenderState.EnableTexture(true);
}
//
// compute similarities for the set of "true" pixels in region.
// affinity matrix is ordered in scanline order
//
void computeAffinities2(const SupportMap& icmap, const float sigma, const float dthresh, SMatrix** affinities)
{
int width = icmap.size(0);
int height = icmap.size(1);
//build a scanline order index
int numPixels = 0;
Util::Array2D<int> index(width,height);
index.init(-1);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
index(x,y) = numPixels;
numPixels++;
}
}
//sparse matrix data
int* nz = new int[numPixels]; //number of non-zero entries in each row
double** vals = new double*[numPixels]; //the values in each row
int** col = new int*[numPixels]; //the column number for each value in the row
int dthreshi = (int)ceil(dthresh);
int wd = (2*dthreshi+1); //window diameter
Util::Array1D<PointIC> connections(wd*wd);
int row = 0;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
row = index(x,y); //the row we are working on
nz[row] = 0; //connection count for row i
int icIndex = 0; //index into sparse supportMap
for (int u = -dthreshi; u <= dthreshi; u++)
{
int yy = y + u;
for (int v = -dthreshi; v <= dthreshi; v++)
{
int xx = x + v;
if (xx < 0 || xx >= width) {continue;}
if (yy < 0 || yy >= height) {continue;}
if (u*u+v*v > dthresh*dthresh) {continue;}
//increment our index into the support map
while( icIndex < icmap(x,y).size() &&
icmap(x,y)(icIndex).y < yy)
{
icIndex++;
}
while( icIndex < icmap(x,y).size() &&
icmap(x,y)(icIndex).x < xx)
{
icIndex++;
}
float pss = 0.0; //connection strength
if ((u == 0) && (v == 0))
{
pss = 1.0f;
}
else
{
float icsim = 0.0f;
if (icIndex < icmap(x,y).size() &&
icmap(x,y)(icIndex).x == xx &&
icmap(x,y)(icIndex).y == yy)
{
icsim = icmap(x,y)(icIndex).sim;
icIndex++;
}
pss = C_IC_SS(1-icsim);
}//if (u==0) & (v==0)
connections(nz[row]).x = xx;
connections(nz[row]).y = yy;
connections(nz[row]).sim = pss;
nz[row]++;
}//for v
}//for u
//fill in entries of sparse matrix
vals[row] = new double[nz[row]];
col[row] = new int[nz[row]];
for (int j = 0; j < nz[row]; j++)
{
float val = exp( -(1-connections(j).sim) / sigma);
assert((val >= 0.0) && (val <= 1.0));
vals[row][j] = val;
col[row][j] = index(connections(j).x,connections(j).y);
}
}//for y
}//for x
*affinities = new SMatrix(numPixels,nz,col,vals);
(*affinities)->symmetrize();
}
TSPtour SimulatedAnnealingVTwo(TSPtour tour, TSPadjMatrix adjM, clock_t t1, clock_t t2, int maxTime)
{
double maxTemp = 1;
double temperature = maxTemp;
double coolingRate = 0.999999;
double minTemp = 1;
int iteration = 0;
int cycles = 100000000;
int curDist = calcTourLen(tour, adjM);
int lastDist = curDist;
int bestDist = curDist;
TSPtour tempTour;
tempTour.length = tour.length;
tempTour.tour = new int[tour.length];
for (int j = 0; j < tour.length; j++)
{
tempTour.tour[j] = tour.tour[j];
}
closeCities closeBy = genCloseByCities(adjM);
int improvements = 0;
while (iteration < cycles && maxTime > ((double)t2 - (double)t1) / CLOCKS_PER_SEC)
{
//pick cities to swap
int city;
do{
city = rand() % adjM.length;
} while (city == tempTour.tour[tour.length - 1]);
int near;
do{
near = closeBy.closeByCities[city][rand() % closeBy.numCloseBy];
} while (city == near);
//std::cout << "City = " << city << " Near = " << near << std::endl;
int cityIndex, nearIndex;
//Find indexes
//std::cout << "Loop";
for (int j = 0; j < tempTour.length; j++)
{
if (tempTour.tour[j] == city){
cityIndex = j;
//std::cout << "City: " << j;
}
else if (tempTour.tour[j] == near){
nearIndex = j;
//std::cout << "Near: " << j;
}
}
//swap
//********************************************************
if (nearIndex == 0)
{
nearIndex = tempTour.length;
}
if (cityIndex == tempTour.length - 1)
{
//cityIndex = 0;
}
if (cityIndex < nearIndex)
{
for (int i = cityIndex; i < nearIndex - 1; i++)
{
tempTour.tour[i] = tempTour.tour[i + 1];
}
tempTour.tour[nearIndex - 1] = city;
//if (cityIndex == 0)
{
//tempTour.tour[tempTour.length - 1] = tempTour.tour[0];
}
}
else if (cityIndex > nearIndex)
{
for (int i = cityIndex; i > nearIndex; i--)
{
tempTour.tour[i] = tempTour.tour[i - 1];
}
tempTour.tour[nearIndex] = city;
}
else
{
std::cout << "error in simulated annealing V2 cityIndex = nearIndex" << std::endl;
}
//********************************************************
curDist = calcTourLen(tempTour, adjM);
//Move is better accept it
if (curDist < lastDist)
{
improvements++;
lastDist = curDist;
if (curDist < bestDist)
{
bestDist = curDist;
for (int j = 0; j < tour.length; j++)
{
tour.tour[j] = tempTour.tour[j];
}
}
}
//Move is worse accept maybe
else if (exp(-(curDist - lastDist) / temperature) >(((double)rand()) / RAND_MAX))
{
lastDist = curDist;
}
//Move not accepted reverse it
else
{
//********************************************************
if (cityIndex < nearIndex)
{
for (int i = nearIndex - 1; i > cityIndex; i--)
{
tempTour.tour[i] = tempTour.tour[i - 1];
}
tempTour.tour[cityIndex] = city;
//if (cityIndex == 0)
{
//tempTour.tour[tempTour.length - 1] = city;
}
}
else if (cityIndex > nearIndex)
{
for (int i = nearIndex; i < cityIndex; i++)
{
tempTour.tour[i] = tempTour.tour[i + 1];
}
tempTour.tour[cityIndex] = city;
}
else
{
std::cout << "error in simulated annealing V2 cityIndex = nearIndex" << std::endl;
}
//********************************************************
}
//Cycle housekeeping
iteration++;
if (temperature > minTemp)
temperature *= coolingRate;
else
temperature = minTemp;
t2 = clock();
}
//std::cout << temperature << std::endl;
return tour;
}
static int
e3(void)
{
int p1;
char *a;
char *p2;
int int1, int2;
a = nxtarg(0);
if (EQ(a, "(")) {
p1 = exp();
if (!EQ(nxtarg(0), ")")) synbad(") expected", "");
return (p1);
}
p2 = nxtarg(1);
ap--;
if ((p2 == 0) || (!EQ(p2, "=") && !EQ(p2, "!="))) {
if (EQ(a, "-r"))
return (tio(nxtarg(0), 4));
if (EQ(a, "-w"))
return (tio(nxtarg(0), 2));
if (EQ(a, "-x"))
return (tio(nxtarg(0), 1));
if (EQ(a, "-d"))
return (filtyp(nxtarg(0), S_IFDIR));
if (EQ(a, "-c"))
return (filtyp(nxtarg(0), S_IFCHR));
if (EQ(a, "-b"))
return (filtyp(nxtarg(0), S_IFBLK));
if (EQ(a, "-f")) {
struct stat statb;
return (stat(nxtarg(0), &statb) >= 0 &&
(statb.st_mode & S_IFMT) != S_IFDIR);
}
if (EQ(a, "-h"))
return (filtyp(nxtarg(0), S_IFLNK));
if (EQ(a, "-u"))
return (ftype(nxtarg(0), S_ISUID));
if (EQ(a, "-g"))
return (ftype(nxtarg(0), S_ISGID));
if (EQ(a, "-k"))
return (ftype(nxtarg(0), S_ISVTX));
if (EQ(a, "-p"))
#ifdef S_IFIFO
return (filtyp(nxtarg(0), S_IFIFO));
#else
return (nxtarg(0), 0);
#endif
if (EQ(a, "-s"))
return (fsizep(nxtarg(0)));
if (EQ(a, "-t"))
if (ap >= ac)
return (isatty(1));
else if (EQ((a = nxtarg(0)), "-a") || EQ(a, "-o")) {
ap--;
return (isatty(1));
} else
return (isatty(atoi(a)));
if (EQ(a, "-n"))
return (!EQ(nxtarg(0), ""));
if (EQ(a, "-z"))
return (EQ(nxtarg(0), ""));
}
p2 = nxtarg(1);
if (p2 == 0)
return (!EQ(a, ""));
if (EQ(p2, "-a") || EQ(p2, "-o")) {
ap--;
return (!EQ(a, ""));
}
if (EQ(p2, "="))
return (EQ(nxtarg(0), a));
if (EQ(p2, "!="))
return (!EQ(nxtarg(0), a));
int1 = atoi(a);
int2 = atoi(nxtarg(0));
if (EQ(p2, "-eq"))
return (int1 == int2);
if (EQ(p2, "-ne"))
return (int1 != int2);
if (EQ(p2, "-gt"))
return (int1 > int2);
if (EQ(p2, "-lt"))
return (int1 < int2);
if (EQ(p2, "-ge"))
return (int1 >= int2);
if (EQ(p2, "-le"))
return (int1 <= int2);
synbad("unknown operator ", p2);
/* NOTREACHED */
return (0);
}
TSPtour SimulatedAnnealing(TSPtour tour, TSPadjMatrix adjM)
{
double maxTemp = 150;
double temperature = maxTemp;
double coolingRate = 0.999999;
double minTemp = 1;
int iteration = 0;
int cycles = 10000000;
int curDist = calcTourLen(tour, adjM);
int lastDist = curDist;
int bestDist = curDist;
TSPtour tempTour;
tempTour.length = tour.length;
tempTour.tour = new int[tour.length];
for (int j = 0; j < tour.length; j++)
{
tempTour.tour[j] = tour.tour[j];
}
closeCities closeBy = genCloseByCities(adjM);
int improvements = 0;
for (int i = 0; i < cycles; i++)
{
//pick cities to swap
int city = rand() % adjM.length;
int near;
do{
near = closeBy.closeByCities[city][rand() % closeBy.numCloseBy];
} while (city == near);
//std::cout << "City = " << city << " Near = " << near << std::endl;
int cityIndex, nearIndex;
//Find indexes
//std::cout << "Loop";
for (int j = 0; j < tempTour.length; j++)
{
if (tempTour.tour[j] == city){
cityIndex = j;
//std::cout << "City: " << j;
}
else if (tempTour.tour[j] == near){
nearIndex = j;
//std::cout << "Near: " << j;
}
}
//std::cout << std::endl;
//swap
tempTour.tour[cityIndex] = near;
tempTour.tour[nearIndex] = city;
curDist = calcTourLen(tempTour, adjM);
//Move is better accept it
if (curDist < lastDist)
{
improvements++;
lastDist = curDist;
if (curDist < bestDist)
{
bestDist = curDist;
for (int j = 0; j < tour.length; j++)
{
tour.tour[j] = tempTour.tour[j];
}
}
}
//Move is worse accept maybe
else if (exp(-(curDist - lastDist) / temperature) > (((double)rand()) / RAND_MAX))
{
lastDist = curDist;
}
//Move not accepted reverse it
else
{
tempTour.tour[cityIndex] = city;
tempTour.tour[nearIndex] = near;
}
//Cycle housekeeping
iteration++;
if (temperature > minTemp)
temperature *= coolingRate;
else
temperature = minTemp;
}
std::cout << temperature << std::endl;
return tour;
}
MagickExport ChannelFeatures *GetImageChannelFeatures(const Image *image,
const size_t distance,ExceptionInfo *exception)
{
typedef struct _ChannelStatistics
{
DoublePixelPacket
direction[4]; /* horizontal, vertical, left and right diagonals */
} ChannelStatistics;
CacheView
*image_view;
ChannelFeatures
*channel_features;
ChannelStatistics
**cooccurrence,
correlation,
*density_x,
*density_xy,
*density_y,
entropy_x,
entropy_xy,
entropy_xy1,
entropy_xy2,
entropy_y,
mean,
**Q,
*sum,
sum_squares,
variance;
LongPixelPacket
gray,
*grays;
MagickBooleanType
status;
register ssize_t
i;
size_t
length;
ssize_t
y,
z;
unsigned int
number_grays;
assert(image != (Image *) NULL);
assert(image->signature == MagickSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
if ((image->columns < (distance+1)) || (image->rows < (distance+1)))
return((ChannelFeatures *) NULL);
length=CompositeChannels+1UL;
channel_features=(ChannelFeatures *) AcquireQuantumMemory(length,
sizeof(*channel_features));
if (channel_features == (ChannelFeatures *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
(void) ResetMagickMemory(channel_features,0,length*
sizeof(*channel_features));
/*
Form grays.
*/
grays=(LongPixelPacket *) AcquireQuantumMemory(MaxMap+1UL,sizeof(*grays));
if (grays == (LongPixelPacket *) NULL)
{
channel_features=(ChannelFeatures *) RelinquishMagickMemory(
channel_features);
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
return(channel_features);
}
for (i=0; i <= (ssize_t) MaxMap; i++)
{
grays[i].red=(~0U);
grays[i].green=(~0U);
grays[i].blue=(~0U);
grays[i].opacity=(~0U);
grays[i].index=(~0U);
}
status=MagickTrue;
image_view=AcquireCacheView(image);
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
for (y=0; y < (ssize_t) image->rows; y++)
{
register const IndexPacket
*restrict indexes;
register const PixelPacket
*restrict p;
register ssize_t
x;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
continue;
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
for (x=0; x < (ssize_t) image->columns; x++)
{
grays[ScaleQuantumToMap(GetPixelRed(p))].red=
ScaleQuantumToMap(GetPixelRed(p));
grays[ScaleQuantumToMap(GetPixelGreen(p))].green=
ScaleQuantumToMap(GetPixelGreen(p));
grays[ScaleQuantumToMap(GetPixelBlue(p))].blue=
ScaleQuantumToMap(GetPixelBlue(p));
if (image->colorspace == CMYKColorspace)
grays[ScaleQuantumToMap(GetPixelIndex(indexes+x))].index=
ScaleQuantumToMap(GetPixelIndex(indexes+x));
if (image->matte != MagickFalse)
grays[ScaleQuantumToMap(GetPixelOpacity(p))].opacity=
ScaleQuantumToMap(GetPixelOpacity(p));
p++;
}
}
image_view=DestroyCacheView(image_view);
if (status == MagickFalse)
{
grays=(LongPixelPacket *) RelinquishMagickMemory(grays);
channel_features=(ChannelFeatures *) RelinquishMagickMemory(
channel_features);
return(channel_features);
}
(void) ResetMagickMemory(&gray,0,sizeof(gray));
for (i=0; i <= (ssize_t) MaxMap; i++)
{
if (grays[i].red != ~0U)
grays[(ssize_t) gray.red++].red=grays[i].red;
if (grays[i].green != ~0U)
grays[(ssize_t) gray.green++].green=grays[i].green;
if (grays[i].blue != ~0U)
grays[(ssize_t) gray.blue++].blue=grays[i].blue;
if (image->colorspace == CMYKColorspace)
if (grays[i].index != ~0U)
grays[(ssize_t) gray.index++].index=grays[i].index;
if (image->matte != MagickFalse)
if (grays[i].opacity != ~0U)
grays[(ssize_t) gray.opacity++].opacity=grays[i].opacity;
}
/*
Allocate spatial dependence matrix.
*/
number_grays=gray.red;
if (gray.green > number_grays)
number_grays=gray.green;
if (gray.blue > number_grays)
number_grays=gray.blue;
if (image->colorspace == CMYKColorspace)
if (gray.index > number_grays)
number_grays=gray.index;
if (image->matte != MagickFalse)
if (gray.opacity > number_grays)
number_grays=gray.opacity;
cooccurrence=(ChannelStatistics **) AcquireQuantumMemory(number_grays,
sizeof(*cooccurrence));
density_x=(ChannelStatistics *) AcquireQuantumMemory(2*(number_grays+1),
sizeof(*density_x));
density_xy=(ChannelStatistics *) AcquireQuantumMemory(2*(number_grays+1),
sizeof(*density_xy));
density_y=(ChannelStatistics *) AcquireQuantumMemory(2*(number_grays+1),
sizeof(*density_y));
Q=(ChannelStatistics **) AcquireQuantumMemory(number_grays,sizeof(*Q));
sum=(ChannelStatistics *) AcquireQuantumMemory(number_grays,sizeof(*sum));
if ((cooccurrence == (ChannelStatistics **) NULL) ||
(density_x == (ChannelStatistics *) NULL) ||
(density_xy == (ChannelStatistics *) NULL) ||
(density_y == (ChannelStatistics *) NULL) ||
(Q == (ChannelStatistics **) NULL) ||
(sum == (ChannelStatistics *) NULL))
{
if (Q != (ChannelStatistics **) NULL)
{
for (i=0; i < (ssize_t) number_grays; i++)
Q[i]=(ChannelStatistics *) RelinquishMagickMemory(Q[i]);
Q=(ChannelStatistics **) RelinquishMagickMemory(Q);
}
if (sum != (ChannelStatistics *) NULL)
sum=(ChannelStatistics *) RelinquishMagickMemory(sum);
if (density_y != (ChannelStatistics *) NULL)
density_y=(ChannelStatistics *) RelinquishMagickMemory(density_y);
if (density_xy != (ChannelStatistics *) NULL)
density_xy=(ChannelStatistics *) RelinquishMagickMemory(density_xy);
if (density_x != (ChannelStatistics *) NULL)
density_x=(ChannelStatistics *) RelinquishMagickMemory(density_x);
if (cooccurrence != (ChannelStatistics **) NULL)
{
for (i=0; i < (ssize_t) number_grays; i++)
cooccurrence[i]=(ChannelStatistics *)
RelinquishMagickMemory(cooccurrence[i]);
cooccurrence=(ChannelStatistics **) RelinquishMagickMemory(
cooccurrence);
}
grays=(LongPixelPacket *) RelinquishMagickMemory(grays);
channel_features=(ChannelFeatures *) RelinquishMagickMemory(
channel_features);
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
return(channel_features);
}
(void) ResetMagickMemory(&correlation,0,sizeof(correlation));
(void) ResetMagickMemory(density_x,0,2*(number_grays+1)*sizeof(*density_x));
(void) ResetMagickMemory(density_xy,0,2*(number_grays+1)*sizeof(*density_xy));
(void) ResetMagickMemory(density_y,0,2*(number_grays+1)*sizeof(*density_y));
(void) ResetMagickMemory(&mean,0,sizeof(mean));
(void) ResetMagickMemory(sum,0,number_grays*sizeof(*sum));
(void) ResetMagickMemory(&sum_squares,0,sizeof(sum_squares));
(void) ResetMagickMemory(density_xy,0,2*number_grays*sizeof(*density_xy));
(void) ResetMagickMemory(&entropy_x,0,sizeof(entropy_x));
(void) ResetMagickMemory(&entropy_xy,0,sizeof(entropy_xy));
(void) ResetMagickMemory(&entropy_xy1,0,sizeof(entropy_xy1));
(void) ResetMagickMemory(&entropy_xy2,0,sizeof(entropy_xy2));
(void) ResetMagickMemory(&entropy_y,0,sizeof(entropy_y));
(void) ResetMagickMemory(&variance,0,sizeof(variance));
for (i=0; i < (ssize_t) number_grays; i++)
{
cooccurrence[i]=(ChannelStatistics *) AcquireQuantumMemory(number_grays,
sizeof(**cooccurrence));
Q[i]=(ChannelStatistics *) AcquireQuantumMemory(number_grays,sizeof(**Q));
if ((cooccurrence[i] == (ChannelStatistics *) NULL) ||
(Q[i] == (ChannelStatistics *) NULL))
break;
(void) ResetMagickMemory(cooccurrence[i],0,number_grays*
sizeof(**cooccurrence));
(void) ResetMagickMemory(Q[i],0,number_grays*sizeof(**Q));
}
if (i < (ssize_t) number_grays)
{
for (i--; i >= 0; i--)
{
if (Q[i] != (ChannelStatistics *) NULL)
Q[i]=(ChannelStatistics *) RelinquishMagickMemory(Q[i]);
if (cooccurrence[i] != (ChannelStatistics *) NULL)
cooccurrence[i]=(ChannelStatistics *)
RelinquishMagickMemory(cooccurrence[i]);
}
Q=(ChannelStatistics **) RelinquishMagickMemory(Q);
cooccurrence=(ChannelStatistics **) RelinquishMagickMemory(cooccurrence);
sum=(ChannelStatistics *) RelinquishMagickMemory(sum);
density_y=(ChannelStatistics *) RelinquishMagickMemory(density_y);
density_xy=(ChannelStatistics *) RelinquishMagickMemory(density_xy);
density_x=(ChannelStatistics *) RelinquishMagickMemory(density_x);
grays=(LongPixelPacket *) RelinquishMagickMemory(grays);
channel_features=(ChannelFeatures *) RelinquishMagickMemory(
channel_features);
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
return(channel_features);
}
/*
Initialize spatial dependence matrix.
*/
status=MagickTrue;
image_view=AcquireCacheView(image);
for (y=0; y < (ssize_t) image->rows; y++)
{
register const IndexPacket
*restrict indexes;
register const PixelPacket
*restrict p;
register ssize_t
x;
ssize_t
i,
offset,
u,
v;
if (status == MagickFalse)
continue;
p=GetCacheViewVirtualPixels(image_view,-(ssize_t) distance,y,image->columns+
2*distance,distance+2,exception);
if (p == (const PixelPacket *) NULL)
{
status=MagickFalse;
continue;
}
indexes=GetCacheViewVirtualIndexQueue(image_view);
p+=distance;
indexes+=distance;
for (x=0; x < (ssize_t) image->columns; x++)
{
for (i=0; i < 4; i++)
{
switch (i)
{
case 0:
default:
{
/*
Horizontal adjacency.
*/
offset=(ssize_t) distance;
break;
}
case 1:
{
/*
Vertical adjacency.
*/
offset=(ssize_t) (image->columns+2*distance);
break;
}
case 2:
{
/*
Right diagonal adjacency.
*/
offset=(ssize_t) ((image->columns+2*distance)-distance);
break;
}
case 3:
{
/*
Left diagonal adjacency.
*/
offset=(ssize_t) ((image->columns+2*distance)+distance);
break;
}
}
u=0;
v=0;
while (grays[u].red != ScaleQuantumToMap(GetPixelRed(p)))
u++;
while (grays[v].red != ScaleQuantumToMap(GetPixelRed(p+offset)))
v++;
cooccurrence[u][v].direction[i].red++;
cooccurrence[v][u].direction[i].red++;
u=0;
v=0;
while (grays[u].green != ScaleQuantumToMap(GetPixelGreen(p)))
u++;
while (grays[v].green != ScaleQuantumToMap(GetPixelGreen(p+offset)))
v++;
cooccurrence[u][v].direction[i].green++;
cooccurrence[v][u].direction[i].green++;
u=0;
v=0;
while (grays[u].blue != ScaleQuantumToMap(GetPixelBlue(p)))
u++;
while (grays[v].blue != ScaleQuantumToMap((p+offset)->blue))
v++;
cooccurrence[u][v].direction[i].blue++;
cooccurrence[v][u].direction[i].blue++;
if (image->colorspace == CMYKColorspace)
{
u=0;
v=0;
while (grays[u].index != ScaleQuantumToMap(GetPixelIndex(indexes+x)))
u++;
while (grays[v].index != ScaleQuantumToMap(GetPixelIndex(indexes+x+offset)))
v++;
cooccurrence[u][v].direction[i].index++;
cooccurrence[v][u].direction[i].index++;
}
if (image->matte != MagickFalse)
{
u=0;
v=0;
while (grays[u].opacity != ScaleQuantumToMap(GetPixelOpacity(p)))
u++;
while (grays[v].opacity != ScaleQuantumToMap((p+offset)->opacity))
v++;
cooccurrence[u][v].direction[i].opacity++;
cooccurrence[v][u].direction[i].opacity++;
}
}
p++;
}
}
grays=(LongPixelPacket *) RelinquishMagickMemory(grays);
image_view=DestroyCacheView(image_view);
if (status == MagickFalse)
{
for (i=0; i < (ssize_t) number_grays; i++)
cooccurrence[i]=(ChannelStatistics *)
RelinquishMagickMemory(cooccurrence[i]);
cooccurrence=(ChannelStatistics **) RelinquishMagickMemory(cooccurrence);
channel_features=(ChannelFeatures *) RelinquishMagickMemory(
channel_features);
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
return(channel_features);
}
/*
Normalize spatial dependence matrix.
*/
for (i=0; i < 4; i++)
{
double
normalize;
register ssize_t
y;
switch (i)
{
case 0:
default:
{
/*
Horizontal adjacency.
*/
normalize=2.0*image->rows*(image->columns-distance);
break;
}
case 1:
{
/*
Vertical adjacency.
*/
normalize=2.0*(image->rows-distance)*image->columns;
break;
}
case 2:
{
/*
Right diagonal adjacency.
*/
normalize=2.0*(image->rows-distance)*(image->columns-distance);
break;
}
case 3:
{
/*
Left diagonal adjacency.
*/
normalize=2.0*(image->rows-distance)*(image->columns-distance);
break;
}
}
normalize=1.0/(fabs((double) normalize) <= MagickEpsilon ? 1.0 : normalize);
for (y=0; y < (ssize_t) number_grays; y++)
{
register ssize_t
x;
for (x=0; x < (ssize_t) number_grays; x++)
{
cooccurrence[x][y].direction[i].red*=normalize;
cooccurrence[x][y].direction[i].green*=normalize;
cooccurrence[x][y].direction[i].blue*=normalize;
if (image->colorspace == CMYKColorspace)
cooccurrence[x][y].direction[i].index*=normalize;
if (image->matte != MagickFalse)
cooccurrence[x][y].direction[i].opacity*=normalize;
}
}
}
/*
Compute texture features.
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
for (i=0; i < 4; i++)
{
register ssize_t
y;
for (y=0; y < (ssize_t) number_grays; y++)
{
register ssize_t
x;
for (x=0; x < (ssize_t) number_grays; x++)
{
/*
Angular second moment: measure of homogeneity of the image.
*/
channel_features[RedChannel].angular_second_moment[i]+=
cooccurrence[x][y].direction[i].red*
cooccurrence[x][y].direction[i].red;
channel_features[GreenChannel].angular_second_moment[i]+=
cooccurrence[x][y].direction[i].green*
cooccurrence[x][y].direction[i].green;
channel_features[BlueChannel].angular_second_moment[i]+=
cooccurrence[x][y].direction[i].blue*
cooccurrence[x][y].direction[i].blue;
if (image->colorspace == CMYKColorspace)
channel_features[BlackChannel].angular_second_moment[i]+=
cooccurrence[x][y].direction[i].index*
cooccurrence[x][y].direction[i].index;
if (image->matte != MagickFalse)
channel_features[OpacityChannel].angular_second_moment[i]+=
cooccurrence[x][y].direction[i].opacity*
cooccurrence[x][y].direction[i].opacity;
/*
Correlation: measure of linear-dependencies in the image.
*/
sum[y].direction[i].red+=cooccurrence[x][y].direction[i].red;
sum[y].direction[i].green+=cooccurrence[x][y].direction[i].green;
sum[y].direction[i].blue+=cooccurrence[x][y].direction[i].blue;
if (image->colorspace == CMYKColorspace)
sum[y].direction[i].index+=cooccurrence[x][y].direction[i].index;
if (image->matte != MagickFalse)
sum[y].direction[i].opacity+=cooccurrence[x][y].direction[i].opacity;
correlation.direction[i].red+=x*y*cooccurrence[x][y].direction[i].red;
correlation.direction[i].green+=x*y*
cooccurrence[x][y].direction[i].green;
correlation.direction[i].blue+=x*y*
cooccurrence[x][y].direction[i].blue;
if (image->colorspace == CMYKColorspace)
correlation.direction[i].index+=x*y*
cooccurrence[x][y].direction[i].index;
if (image->matte != MagickFalse)
correlation.direction[i].opacity+=x*y*
cooccurrence[x][y].direction[i].opacity;
/*
Inverse Difference Moment.
*/
channel_features[RedChannel].inverse_difference_moment[i]+=
cooccurrence[x][y].direction[i].red/((y-x)*(y-x)+1);
channel_features[GreenChannel].inverse_difference_moment[i]+=
cooccurrence[x][y].direction[i].green/((y-x)*(y-x)+1);
channel_features[BlueChannel].inverse_difference_moment[i]+=
cooccurrence[x][y].direction[i].blue/((y-x)*(y-x)+1);
if (image->colorspace == CMYKColorspace)
channel_features[IndexChannel].inverse_difference_moment[i]+=
cooccurrence[x][y].direction[i].index/((y-x)*(y-x)+1);
if (image->matte != MagickFalse)
channel_features[OpacityChannel].inverse_difference_moment[i]+=
cooccurrence[x][y].direction[i].opacity/((y-x)*(y-x)+1);
/*
Sum average.
*/
density_xy[y+x+2].direction[i].red+=
cooccurrence[x][y].direction[i].red;
density_xy[y+x+2].direction[i].green+=
cooccurrence[x][y].direction[i].green;
density_xy[y+x+2].direction[i].blue+=
cooccurrence[x][y].direction[i].blue;
if (image->colorspace == CMYKColorspace)
density_xy[y+x+2].direction[i].index+=
cooccurrence[x][y].direction[i].index;
if (image->matte != MagickFalse)
density_xy[y+x+2].direction[i].opacity+=
cooccurrence[x][y].direction[i].opacity;
/*
Entropy.
*/
channel_features[RedChannel].entropy[i]-=
cooccurrence[x][y].direction[i].red*
log10(cooccurrence[x][y].direction[i].red+MagickEpsilon);
channel_features[GreenChannel].entropy[i]-=
cooccurrence[x][y].direction[i].green*
log10(cooccurrence[x][y].direction[i].green+MagickEpsilon);
channel_features[BlueChannel].entropy[i]-=
cooccurrence[x][y].direction[i].blue*
log10(cooccurrence[x][y].direction[i].blue+MagickEpsilon);
if (image->colorspace == CMYKColorspace)
channel_features[IndexChannel].entropy[i]-=
cooccurrence[x][y].direction[i].index*
log10(cooccurrence[x][y].direction[i].index+MagickEpsilon);
if (image->matte != MagickFalse)
channel_features[OpacityChannel].entropy[i]-=
cooccurrence[x][y].direction[i].opacity*
log10(cooccurrence[x][y].direction[i].opacity+MagickEpsilon);
/*
Information Measures of Correlation.
*/
density_x[x].direction[i].red+=cooccurrence[x][y].direction[i].red;
density_x[x].direction[i].green+=cooccurrence[x][y].direction[i].green;
density_x[x].direction[i].blue+=cooccurrence[x][y].direction[i].blue;
if (image->colorspace == CMYKColorspace)
density_x[x].direction[i].index+=
cooccurrence[x][y].direction[i].index;
if (image->matte != MagickFalse)
density_x[x].direction[i].opacity+=
cooccurrence[x][y].direction[i].opacity;
density_y[y].direction[i].red+=cooccurrence[x][y].direction[i].red;
density_y[y].direction[i].green+=cooccurrence[x][y].direction[i].green;
density_y[y].direction[i].blue+=cooccurrence[x][y].direction[i].blue;
if (image->colorspace == CMYKColorspace)
density_y[y].direction[i].index+=
cooccurrence[x][y].direction[i].index;
if (image->matte != MagickFalse)
density_y[y].direction[i].opacity+=
cooccurrence[x][y].direction[i].opacity;
}
mean.direction[i].red+=y*sum[y].direction[i].red;
sum_squares.direction[i].red+=y*y*sum[y].direction[i].red;
mean.direction[i].green+=y*sum[y].direction[i].green;
sum_squares.direction[i].green+=y*y*sum[y].direction[i].green;
mean.direction[i].blue+=y*sum[y].direction[i].blue;
sum_squares.direction[i].blue+=y*y*sum[y].direction[i].blue;
if (image->colorspace == CMYKColorspace)
{
mean.direction[i].index+=y*sum[y].direction[i].index;
sum_squares.direction[i].index+=y*y*sum[y].direction[i].index;
}
if (image->matte != MagickFalse)
{
mean.direction[i].opacity+=y*sum[y].direction[i].opacity;
sum_squares.direction[i].opacity+=y*y*sum[y].direction[i].opacity;
}
}
/*
Correlation: measure of linear-dependencies in the image.
*/
channel_features[RedChannel].correlation[i]=
(correlation.direction[i].red-mean.direction[i].red*
mean.direction[i].red)/(sqrt(sum_squares.direction[i].red-
(mean.direction[i].red*mean.direction[i].red))*sqrt(
sum_squares.direction[i].red-(mean.direction[i].red*
mean.direction[i].red)));
channel_features[GreenChannel].correlation[i]=
(correlation.direction[i].green-mean.direction[i].green*
mean.direction[i].green)/(sqrt(sum_squares.direction[i].green-
(mean.direction[i].green*mean.direction[i].green))*sqrt(
sum_squares.direction[i].green-(mean.direction[i].green*
mean.direction[i].green)));
channel_features[BlueChannel].correlation[i]=
(correlation.direction[i].blue-mean.direction[i].blue*
mean.direction[i].blue)/(sqrt(sum_squares.direction[i].blue-
(mean.direction[i].blue*mean.direction[i].blue))*sqrt(
sum_squares.direction[i].blue-(mean.direction[i].blue*
mean.direction[i].blue)));
if (image->colorspace == CMYKColorspace)
channel_features[IndexChannel].correlation[i]=
(correlation.direction[i].index-mean.direction[i].index*
mean.direction[i].index)/(sqrt(sum_squares.direction[i].index-
(mean.direction[i].index*mean.direction[i].index))*sqrt(
sum_squares.direction[i].index-(mean.direction[i].index*
mean.direction[i].index)));
if (image->matte != MagickFalse)
channel_features[OpacityChannel].correlation[i]=
(correlation.direction[i].opacity-mean.direction[i].opacity*
mean.direction[i].opacity)/(sqrt(sum_squares.direction[i].opacity-
(mean.direction[i].opacity*mean.direction[i].opacity))*sqrt(
sum_squares.direction[i].opacity-(mean.direction[i].opacity*
mean.direction[i].opacity)));
}
/*
Compute more texture features.
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
for (i=0; i < 4; i++)
{
register ssize_t
x;
for (x=2; x < (ssize_t) (2*number_grays); x++)
{
/*
Sum average.
*/
channel_features[RedChannel].sum_average[i]+=
x*density_xy[x].direction[i].red;
channel_features[GreenChannel].sum_average[i]+=
x*density_xy[x].direction[i].green;
channel_features[BlueChannel].sum_average[i]+=
x*density_xy[x].direction[i].blue;
if (image->colorspace == CMYKColorspace)
channel_features[IndexChannel].sum_average[i]+=
x*density_xy[x].direction[i].index;
if (image->matte != MagickFalse)
channel_features[OpacityChannel].sum_average[i]+=
x*density_xy[x].direction[i].opacity;
/*
Sum entropy.
*/
channel_features[RedChannel].sum_entropy[i]-=
density_xy[x].direction[i].red*
log10(density_xy[x].direction[i].red+MagickEpsilon);
channel_features[GreenChannel].sum_entropy[i]-=
density_xy[x].direction[i].green*
log10(density_xy[x].direction[i].green+MagickEpsilon);
channel_features[BlueChannel].sum_entropy[i]-=
density_xy[x].direction[i].blue*
log10(density_xy[x].direction[i].blue+MagickEpsilon);
if (image->colorspace == CMYKColorspace)
channel_features[IndexChannel].sum_entropy[i]-=
density_xy[x].direction[i].index*
log10(density_xy[x].direction[i].index+MagickEpsilon);
if (image->matte != MagickFalse)
channel_features[OpacityChannel].sum_entropy[i]-=
density_xy[x].direction[i].opacity*
log10(density_xy[x].direction[i].opacity+MagickEpsilon);
/*
Sum variance.
*/
channel_features[RedChannel].sum_variance[i]+=
(x-channel_features[RedChannel].sum_entropy[i])*
(x-channel_features[RedChannel].sum_entropy[i])*
density_xy[x].direction[i].red;
channel_features[GreenChannel].sum_variance[i]+=
(x-channel_features[GreenChannel].sum_entropy[i])*
(x-channel_features[GreenChannel].sum_entropy[i])*
density_xy[x].direction[i].green;
channel_features[BlueChannel].sum_variance[i]+=
(x-channel_features[BlueChannel].sum_entropy[i])*
(x-channel_features[BlueChannel].sum_entropy[i])*
density_xy[x].direction[i].blue;
if (image->colorspace == CMYKColorspace)
channel_features[IndexChannel].sum_variance[i]+=
(x-channel_features[IndexChannel].sum_entropy[i])*
(x-channel_features[IndexChannel].sum_entropy[i])*
density_xy[x].direction[i].index;
if (image->matte != MagickFalse)
channel_features[OpacityChannel].sum_variance[i]+=
(x-channel_features[OpacityChannel].sum_entropy[i])*
(x-channel_features[OpacityChannel].sum_entropy[i])*
density_xy[x].direction[i].opacity;
}
}
/*
Compute more texture features.
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
for (i=0; i < 4; i++)
{
register ssize_t
y;
for (y=0; y < (ssize_t) number_grays; y++)
{
register ssize_t
x;
for (x=0; x < (ssize_t) number_grays; x++)
{
/*
Sum of Squares: Variance
*/
variance.direction[i].red+=(y-mean.direction[i].red+1)*
(y-mean.direction[i].red+1)*cooccurrence[x][y].direction[i].red;
variance.direction[i].green+=(y-mean.direction[i].green+1)*
(y-mean.direction[i].green+1)*cooccurrence[x][y].direction[i].green;
variance.direction[i].blue+=(y-mean.direction[i].blue+1)*
(y-mean.direction[i].blue+1)*cooccurrence[x][y].direction[i].blue;
if (image->colorspace == CMYKColorspace)
variance.direction[i].index+=(y-mean.direction[i].index+1)*
(y-mean.direction[i].index+1)*cooccurrence[x][y].direction[i].index;
if (image->matte != MagickFalse)
variance.direction[i].opacity+=(y-mean.direction[i].opacity+1)*
(y-mean.direction[i].opacity+1)*
cooccurrence[x][y].direction[i].opacity;
/*
Sum average / Difference Variance.
*/
density_xy[MagickAbsoluteValue(y-x)].direction[i].red+=
cooccurrence[x][y].direction[i].red;
density_xy[MagickAbsoluteValue(y-x)].direction[i].green+=
cooccurrence[x][y].direction[i].green;
density_xy[MagickAbsoluteValue(y-x)].direction[i].blue+=
cooccurrence[x][y].direction[i].blue;
if (image->colorspace == CMYKColorspace)
density_xy[MagickAbsoluteValue(y-x)].direction[i].index+=
cooccurrence[x][y].direction[i].index;
if (image->matte != MagickFalse)
density_xy[MagickAbsoluteValue(y-x)].direction[i].opacity+=
cooccurrence[x][y].direction[i].opacity;
/*
Information Measures of Correlation.
*/
entropy_xy.direction[i].red-=cooccurrence[x][y].direction[i].red*
log10(cooccurrence[x][y].direction[i].red+MagickEpsilon);
entropy_xy.direction[i].green-=cooccurrence[x][y].direction[i].green*
log10(cooccurrence[x][y].direction[i].green+MagickEpsilon);
entropy_xy.direction[i].blue-=cooccurrence[x][y].direction[i].blue*
log10(cooccurrence[x][y].direction[i].blue+MagickEpsilon);
if (image->colorspace == CMYKColorspace)
entropy_xy.direction[i].index-=cooccurrence[x][y].direction[i].index*
log10(cooccurrence[x][y].direction[i].index+MagickEpsilon);
if (image->matte != MagickFalse)
entropy_xy.direction[i].opacity-=
cooccurrence[x][y].direction[i].opacity*log10(
cooccurrence[x][y].direction[i].opacity+MagickEpsilon);
entropy_xy1.direction[i].red-=(cooccurrence[x][y].direction[i].red*
log10(density_x[x].direction[i].red*density_y[y].direction[i].red+
MagickEpsilon));
entropy_xy1.direction[i].green-=(cooccurrence[x][y].direction[i].green*
log10(density_x[x].direction[i].green*density_y[y].direction[i].green+
MagickEpsilon));
entropy_xy1.direction[i].blue-=(cooccurrence[x][y].direction[i].blue*
log10(density_x[x].direction[i].blue*density_y[y].direction[i].blue+
MagickEpsilon));
if (image->colorspace == CMYKColorspace)
entropy_xy1.direction[i].index-=(
cooccurrence[x][y].direction[i].index*log10(
density_x[x].direction[i].index*density_y[y].direction[i].index+
MagickEpsilon));
if (image->matte != MagickFalse)
entropy_xy1.direction[i].opacity-=(
cooccurrence[x][y].direction[i].opacity*log10(
density_x[x].direction[i].opacity*density_y[y].direction[i].opacity+
MagickEpsilon));
entropy_xy2.direction[i].red-=(density_x[x].direction[i].red*
density_y[y].direction[i].red*log10(density_x[x].direction[i].red*
density_y[y].direction[i].red+MagickEpsilon));
entropy_xy2.direction[i].green-=(density_x[x].direction[i].green*
density_y[y].direction[i].green*log10(density_x[x].direction[i].green*
density_y[y].direction[i].green+MagickEpsilon));
entropy_xy2.direction[i].blue-=(density_x[x].direction[i].blue*
density_y[y].direction[i].blue*log10(density_x[x].direction[i].blue*
density_y[y].direction[i].blue+MagickEpsilon));
if (image->colorspace == CMYKColorspace)
entropy_xy2.direction[i].index-=(density_x[x].direction[i].index*
density_y[y].direction[i].index*log10(
density_x[x].direction[i].index*density_y[y].direction[i].index+
MagickEpsilon));
if (image->matte != MagickFalse)
entropy_xy2.direction[i].opacity-=(density_x[x].direction[i].opacity*
density_y[y].direction[i].opacity*log10(
density_x[x].direction[i].opacity*density_y[y].direction[i].opacity+
MagickEpsilon));
}
}
channel_features[RedChannel].variance_sum_of_squares[i]=
variance.direction[i].red;
channel_features[GreenChannel].variance_sum_of_squares[i]=
variance.direction[i].green;
channel_features[BlueChannel].variance_sum_of_squares[i]=
variance.direction[i].blue;
if (image->colorspace == CMYKColorspace)
channel_features[RedChannel].variance_sum_of_squares[i]=
variance.direction[i].index;
if (image->matte != MagickFalse)
channel_features[RedChannel].variance_sum_of_squares[i]=
variance.direction[i].opacity;
}
/*
Compute more texture features.
*/
(void) ResetMagickMemory(&variance,0,sizeof(variance));
(void) ResetMagickMemory(&sum_squares,0,sizeof(sum_squares));
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
for (i=0; i < 4; i++)
{
register ssize_t
x;
for (x=0; x < (ssize_t) number_grays; x++)
{
/*
Difference variance.
*/
variance.direction[i].red+=density_xy[x].direction[i].red;
variance.direction[i].green+=density_xy[x].direction[i].green;
variance.direction[i].blue+=density_xy[x].direction[i].blue;
if (image->colorspace == CMYKColorspace)
variance.direction[i].index+=density_xy[x].direction[i].index;
if (image->matte != MagickFalse)
variance.direction[i].opacity+=density_xy[x].direction[i].opacity;
sum_squares.direction[i].red+=density_xy[x].direction[i].red*
density_xy[x].direction[i].red;
sum_squares.direction[i].green+=density_xy[x].direction[i].green*
density_xy[x].direction[i].green;
sum_squares.direction[i].blue+=density_xy[x].direction[i].blue*
density_xy[x].direction[i].blue;
if (image->colorspace == CMYKColorspace)
sum_squares.direction[i].index+=density_xy[x].direction[i].index*
density_xy[x].direction[i].index;
if (image->matte != MagickFalse)
sum_squares.direction[i].opacity+=density_xy[x].direction[i].opacity*
density_xy[x].direction[i].opacity;
/*
Difference entropy.
*/
channel_features[RedChannel].difference_entropy[i]-=
density_xy[x].direction[i].red*
log10(density_xy[x].direction[i].red+MagickEpsilon);
channel_features[GreenChannel].difference_entropy[i]-=
density_xy[x].direction[i].green*
log10(density_xy[x].direction[i].green+MagickEpsilon);
channel_features[BlueChannel].difference_entropy[i]-=
density_xy[x].direction[i].blue*
log10(density_xy[x].direction[i].blue+MagickEpsilon);
if (image->colorspace == CMYKColorspace)
channel_features[IndexChannel].difference_entropy[i]-=
density_xy[x].direction[i].index*
log10(density_xy[x].direction[i].index+MagickEpsilon);
if (image->matte != MagickFalse)
channel_features[OpacityChannel].difference_entropy[i]-=
density_xy[x].direction[i].opacity*
log10(density_xy[x].direction[i].opacity+MagickEpsilon);
/*
Information Measures of Correlation.
*/
entropy_x.direction[i].red-=(density_x[x].direction[i].red*
log10(density_x[x].direction[i].red+MagickEpsilon));
entropy_x.direction[i].green-=(density_x[x].direction[i].green*
log10(density_x[x].direction[i].green+MagickEpsilon));
entropy_x.direction[i].blue-=(density_x[x].direction[i].blue*
log10(density_x[x].direction[i].blue+MagickEpsilon));
if (image->colorspace == CMYKColorspace)
entropy_x.direction[i].index-=(density_x[x].direction[i].index*
log10(density_x[x].direction[i].index+MagickEpsilon));
if (image->matte != MagickFalse)
entropy_x.direction[i].opacity-=(density_x[x].direction[i].opacity*
log10(density_x[x].direction[i].opacity+MagickEpsilon));
entropy_y.direction[i].red-=(density_y[x].direction[i].red*
log10(density_y[x].direction[i].red+MagickEpsilon));
entropy_y.direction[i].green-=(density_y[x].direction[i].green*
log10(density_y[x].direction[i].green+MagickEpsilon));
entropy_y.direction[i].blue-=(density_y[x].direction[i].blue*
log10(density_y[x].direction[i].blue+MagickEpsilon));
if (image->colorspace == CMYKColorspace)
entropy_y.direction[i].index-=(density_y[x].direction[i].index*
log10(density_y[x].direction[i].index+MagickEpsilon));
if (image->matte != MagickFalse)
entropy_y.direction[i].opacity-=(density_y[x].direction[i].opacity*
log10(density_y[x].direction[i].opacity+MagickEpsilon));
}
/*
Difference variance.
*/
channel_features[RedChannel].difference_variance[i]=
(((double) number_grays*number_grays*sum_squares.direction[i].red)-
(variance.direction[i].red*variance.direction[i].red))/
((double) number_grays*number_grays*number_grays*number_grays);
channel_features[GreenChannel].difference_variance[i]=
(((double) number_grays*number_grays*sum_squares.direction[i].green)-
(variance.direction[i].green*variance.direction[i].green))/
((double) number_grays*number_grays*number_grays*number_grays);
channel_features[BlueChannel].difference_variance[i]=
(((double) number_grays*number_grays*sum_squares.direction[i].blue)-
(variance.direction[i].blue*variance.direction[i].blue))/
((double) number_grays*number_grays*number_grays*number_grays);
if (image->matte != MagickFalse)
channel_features[OpacityChannel].difference_variance[i]=
(((double) number_grays*number_grays*sum_squares.direction[i].opacity)-
(variance.direction[i].opacity*variance.direction[i].opacity))/
((double) number_grays*number_grays*number_grays*number_grays);
if (image->colorspace == CMYKColorspace)
channel_features[IndexChannel].difference_variance[i]=
(((double) number_grays*number_grays*sum_squares.direction[i].index)-
(variance.direction[i].index*variance.direction[i].index))/
((double) number_grays*number_grays*number_grays*number_grays);
/*
Information Measures of Correlation.
*/
channel_features[RedChannel].measure_of_correlation_1[i]=
(entropy_xy.direction[i].red-entropy_xy1.direction[i].red)/
(entropy_x.direction[i].red > entropy_y.direction[i].red ?
entropy_x.direction[i].red : entropy_y.direction[i].red);
channel_features[GreenChannel].measure_of_correlation_1[i]=
(entropy_xy.direction[i].green-entropy_xy1.direction[i].green)/
(entropy_x.direction[i].green > entropy_y.direction[i].green ?
entropy_x.direction[i].green : entropy_y.direction[i].green);
channel_features[BlueChannel].measure_of_correlation_1[i]=
(entropy_xy.direction[i].blue-entropy_xy1.direction[i].blue)/
(entropy_x.direction[i].blue > entropy_y.direction[i].blue ?
entropy_x.direction[i].blue : entropy_y.direction[i].blue);
if (image->colorspace == CMYKColorspace)
channel_features[IndexChannel].measure_of_correlation_1[i]=
(entropy_xy.direction[i].index-entropy_xy1.direction[i].index)/
(entropy_x.direction[i].index > entropy_y.direction[i].index ?
entropy_x.direction[i].index : entropy_y.direction[i].index);
if (image->matte != MagickFalse)
channel_features[OpacityChannel].measure_of_correlation_1[i]=
(entropy_xy.direction[i].opacity-entropy_xy1.direction[i].opacity)/
(entropy_x.direction[i].opacity > entropy_y.direction[i].opacity ?
entropy_x.direction[i].opacity : entropy_y.direction[i].opacity);
channel_features[RedChannel].measure_of_correlation_2[i]=
(sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].red-
entropy_xy.direction[i].red)))));
channel_features[GreenChannel].measure_of_correlation_2[i]=
(sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].green-
entropy_xy.direction[i].green)))));
channel_features[BlueChannel].measure_of_correlation_2[i]=
(sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].blue-
entropy_xy.direction[i].blue)))));
if (image->colorspace == CMYKColorspace)
channel_features[IndexChannel].measure_of_correlation_2[i]=
(sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].index-
entropy_xy.direction[i].index)))));
if (image->matte != MagickFalse)
channel_features[OpacityChannel].measure_of_correlation_2[i]=
(sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].opacity-
entropy_xy.direction[i].opacity)))));
}
/*
Compute more texture features.
*/
#if defined(MAGICKCORE_OPENMP_SUPPORT)
#pragma omp parallel for schedule(dynamic,4) shared(status)
#endif
for (i=0; i < 4; i++)
{
for (z=0; z < (ssize_t) number_grays; z++)
{
register ssize_t
y;
ChannelStatistics
pixel;
(void) ResetMagickMemory(&pixel,0,sizeof(pixel));
for (y=0; y < (ssize_t) number_grays; y++)
{
register ssize_t
x;
for (x=0; x < (ssize_t) number_grays; x++)
{
/*
Contrast: amount of local variations present in an image.
*/
if (((y-x) == z) || ((x-y) == z))
{
pixel.direction[i].red+=cooccurrence[x][y].direction[i].red;
pixel.direction[i].green+=cooccurrence[x][y].direction[i].green;
pixel.direction[i].blue+=cooccurrence[x][y].direction[i].blue;
if (image->colorspace == CMYKColorspace)
pixel.direction[i].index+=cooccurrence[x][y].direction[i].index;
if (image->matte != MagickFalse)
pixel.direction[i].opacity+=
cooccurrence[x][y].direction[i].opacity;
}
/*
Maximum Correlation Coefficient.
*/
Q[z][y].direction[i].red+=cooccurrence[z][x].direction[i].red*
cooccurrence[y][x].direction[i].red/density_x[z].direction[i].red/
density_y[x].direction[i].red;
Q[z][y].direction[i].green+=cooccurrence[z][x].direction[i].green*
cooccurrence[y][x].direction[i].green/
density_x[z].direction[i].green/density_y[x].direction[i].red;
Q[z][y].direction[i].blue+=cooccurrence[z][x].direction[i].blue*
cooccurrence[y][x].direction[i].blue/density_x[z].direction[i].blue/
density_y[x].direction[i].blue;
if (image->colorspace == CMYKColorspace)
Q[z][y].direction[i].index+=cooccurrence[z][x].direction[i].index*
cooccurrence[y][x].direction[i].index/
density_x[z].direction[i].index/density_y[x].direction[i].index;
if (image->matte != MagickFalse)
Q[z][y].direction[i].opacity+=
cooccurrence[z][x].direction[i].opacity*
cooccurrence[y][x].direction[i].opacity/
density_x[z].direction[i].opacity/
density_y[x].direction[i].opacity;
}
}
channel_features[RedChannel].contrast[i]+=z*z*pixel.direction[i].red;
channel_features[GreenChannel].contrast[i]+=z*z*pixel.direction[i].green;
channel_features[BlueChannel].contrast[i]+=z*z*pixel.direction[i].blue;
if (image->colorspace == CMYKColorspace)
channel_features[BlackChannel].contrast[i]+=z*z*
pixel.direction[i].index;
if (image->matte != MagickFalse)
channel_features[OpacityChannel].contrast[i]+=z*z*
pixel.direction[i].opacity;
}
/*
Maximum Correlation Coefficient.
Future: return second largest eigenvalue of Q.
*/
channel_features[RedChannel].maximum_correlation_coefficient[i]=
sqrt((double) -1.0);
channel_features[GreenChannel].maximum_correlation_coefficient[i]=
sqrt((double) -1.0);
channel_features[BlueChannel].maximum_correlation_coefficient[i]=
sqrt((double) -1.0);
if (image->colorspace == CMYKColorspace)
channel_features[IndexChannel].maximum_correlation_coefficient[i]=
sqrt((double) -1.0);
if (image->matte != MagickFalse)
channel_features[OpacityChannel].maximum_correlation_coefficient[i]=
sqrt((double) -1.0);
}
/*
Relinquish resources.
*/
sum=(ChannelStatistics *) RelinquishMagickMemory(sum);
for (i=0; i < (ssize_t) number_grays; i++)
Q[i]=(ChannelStatistics *) RelinquishMagickMemory(Q[i]);
Q=(ChannelStatistics **) RelinquishMagickMemory(Q);
density_y=(ChannelStatistics *) RelinquishMagickMemory(density_y);
density_xy=(ChannelStatistics *) RelinquishMagickMemory(density_xy);
density_x=(ChannelStatistics *) RelinquishMagickMemory(density_x);
for (i=0; i < (ssize_t) number_grays; i++)
cooccurrence[i]=(ChannelStatistics *)
RelinquishMagickMemory(cooccurrence[i]);
cooccurrence=(ChannelStatistics **) RelinquishMagickMemory(cooccurrence);
return(channel_features);
}
int stream_component_open(VideoState *is, int stream_index) {
AVFormatContext *pFormatCtx = is->pFormatCtx;
AVCodecContext *codecCtx = NULL;
AVCodec *codec = NULL;
AVDictionary *optionsDict = NULL;
SDL_AudioSpec wanted_spec, spec;
if (stream_index < 0 || stream_index >= pFormatCtx->nb_streams) {
return -1;
}
// Get a pointer to the codec context for the video stream
codecCtx = pFormatCtx->streams[stream_index]->codec;
if (codecCtx->codec_type == AVMEDIA_TYPE_AUDIO) {
// Set audio settings from codec info
wanted_spec.freq = codecCtx->sample_rate;
wanted_spec.format = AUDIO_S16SYS;
wanted_spec.channels = codecCtx->channels;
wanted_spec.silence = 0;
wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
wanted_spec.callback = audio_callback;
wanted_spec.userdata = is;
if (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
return -1;
}
is->audio_hw_buf_size = spec.size;
}
codec = avcodec_find_decoder(codecCtx->codec_id);
if (!codec || (avcodec_open2(codecCtx, codec, &optionsDict) < 0)) {
fprintf(stderr, "Unsupported codec!\n");
return -1;
}
switch (codecCtx->codec_type) {
case AVMEDIA_TYPE_AUDIO:
is->audioStream = stream_index;
is->audio_st = pFormatCtx->streams[stream_index];
is->audio_buf_size = 0;
is->audio_buf_index = 0;
/* averaging filter for audio sync */
is->audio_diff_avg_coef = exp(log(0.01 / AUDIO_DIFF_AVG_NB));
is->audio_diff_avg_count = 0;
/* Correct audio only if larger error than this */
is->audio_diff_threshold = 2.0 * SDL_AUDIO_BUFFER_SIZE / codecCtx->sample_rate;
memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
packet_queue_init(&is->audioq);
SDL_PauseAudio(0);
break;
case AVMEDIA_TYPE_VIDEO:
is->videoStream = stream_index;
is->video_st = pFormatCtx->streams[stream_index];
is->frame_timer = (double) av_gettime() / 1000000.0;
is->frame_last_delay = 40e-3;
is->video_current_pts_time = av_gettime();
packet_queue_init(&is->videoq);
is->video_tid = SDL_CreateThread(video_thread, is);
is->sws_ctx =
sws_getContext
(
is->video_st->codec->width,
is->video_st->codec->height,
is->video_st->codec->pix_fmt,
is->video_st->codec->width,
is->video_st->codec->height,
PIX_FMT_YUV420P,
SWS_BILINEAR,
NULL,
NULL,
NULL
);
codecCtx->get_buffer2 = our_get_buffer;
codecCtx->release_buffer = our_release_buffer;
break;
default:
break;
}
return 0;
}
//--------------------------------------------------------------------------
// Process one of the nested EXIF directories.
//--------------------------------------------------------------------------
void CExifParse::ProcessDir(const unsigned char* const DirStart,
const unsigned char* const OffsetBase,
const unsigned ExifLength,
int NestingLevel)
{
if (NestingLevel > 4)
{
ErrNonfatal("Maximum directory nesting exceeded (corrupt exif header)", 0,0);
return;
}
char IndentString[25];
memset(IndentString, ' ', 25);
IndentString[NestingLevel * 4] = '\0';
int NumDirEntries = Get16((void*)DirStart, m_MotorolaOrder);
const unsigned char* const DirEnd = DIR_ENTRY_ADDR(DirStart, NumDirEntries);
if (DirEnd+4 > (OffsetBase+ExifLength))
{
if (DirEnd+2 == OffsetBase+ExifLength || DirEnd == OffsetBase+ExifLength)
{
// Version 1.3 of jhead would truncate a bit too much.
// This also caught later on as well.
}
else
{
ErrNonfatal("Illegally sized directory", 0,0);
return;
}
}
for (int de=0;de<NumDirEntries;de++)
{
int Tag, Format, Components;
unsigned char* ValuePtr;
int ByteCount;
const unsigned char* const DirEntry = DIR_ENTRY_ADDR(DirStart, de);
Tag = Get16(DirEntry, m_MotorolaOrder);
Format = Get16(DirEntry+2, m_MotorolaOrder);
Components = Get32(DirEntry+4, m_MotorolaOrder);
if (Format <= 0 || Format > NUM_FORMATS)
{
ErrNonfatal("Illegal number format %d for tag %04x", Format, Tag);
continue;
}
if ((unsigned)Components > 0x10000)
{
ErrNonfatal("Illegal number of components %d for tag %04x", Components, Tag);
continue;
}
ByteCount = Components * BytesPerFormat[Format - 1];
if (ByteCount > 4)
{
unsigned OffsetVal;
OffsetVal = (unsigned)Get32(DirEntry+8, m_MotorolaOrder);
// If its bigger than 4 bytes, the dir entry contains an offset.
if (OffsetVal+ByteCount > ExifLength)
{
// Bogus pointer offset and / or bytecount value
ErrNonfatal("Illegal value pointer for tag %04x", Tag,0);
continue;
}
ValuePtr = (unsigned char*)(OffsetBase+OffsetVal);
if (OffsetVal > m_LargestExifOffset)
{
m_LargestExifOffset = OffsetVal;
}
}
else {
// 4 bytes or less and value is in the dir entry itself
ValuePtr = (unsigned char*)(DirEntry+8);
}
// Extract useful components of tag
switch(Tag)
{
case TAG_DESCRIPTION:
{
int length = max(ByteCount, 0);
length = min(length, MAX_COMMENT);
strncpy(m_ExifInfo->Description, (char *)ValuePtr, length);
m_ExifInfo->Description[length] = '\0';
break;
}
case TAG_MAKE:
{
int space = sizeof(m_ExifInfo->CameraMake);
if (space > 0)
{
strncpy(m_ExifInfo->CameraMake, (char *)ValuePtr, space - 1);
m_ExifInfo->CameraMake[space - 1] = '\0';
}
break;
}
case TAG_MODEL:
{
int space = sizeof(m_ExifInfo->CameraModel);
if (space > 0)
{
strncpy(m_ExifInfo->CameraModel, (char *)ValuePtr, space - 1);
m_ExifInfo->CameraModel[space - 1] = '\0';
}
break;
}
// case TAG_SOFTWARE: strncpy(m_ExifInfo->Software, ValuePtr, 5); break;
case TAG_FOCALPLANEXRES: m_FocalPlaneXRes = ConvertAnyFormat(ValuePtr, Format); break;
case TAG_THUMBNAIL_OFFSET: m_ExifInfo->ThumbnailOffset = (unsigned)ConvertAnyFormat(ValuePtr, Format); break;
case TAG_THUMBNAIL_LENGTH: m_ExifInfo->ThumbnailSize = (unsigned)ConvertAnyFormat(ValuePtr, Format); break;
case TAG_MAKER_NOTE:
continue;
break;
case TAG_DATETIME_ORIGINAL:
{
int space = sizeof(m_ExifInfo->DateTime);
if (space > 0)
{
strncpy(m_ExifInfo->DateTime, (char *)ValuePtr, space - 1);
m_ExifInfo->DateTime[space - 1] = '\0';
// If we get a DATETIME_ORIGINAL, we use that one.
m_DateFound = true;
}
break;
}
case TAG_DATETIME_DIGITIZED:
case TAG_DATETIME:
{
if (m_DateFound == false)
{
// If we don't already have a DATETIME_ORIGINAL, use whatever
// time fields we may have.
int space = sizeof(m_ExifInfo->DateTime);
if (space > 0)
{
strncpy(m_ExifInfo->DateTime, (char *)ValuePtr, space - 1);
m_ExifInfo->DateTime[space - 1] = '\0';
}
}
break;
}
case TAG_USERCOMMENT:
{
// The UserComment allows comments without the charset limitations of ImageDescription.
// Therefore the UserComment field is prefixed by a CharacterCode field (8 Byte):
// - ASCII: 'ASCII\0\0\0'
// - Unicode: 'UNICODE\0'
// - JIS X208-1990: 'JIS\0\0\0\0\0'
// - Unknown: '\0\0\0\0\0\0\0\0' (application specific)
m_ExifInfo->CommentsCharset = EXIF_COMMENT_CHARSET_UNKNOWN;
const int EXIF_COMMENT_CHARSET_LENGTH = 8;
if (ByteCount >= EXIF_COMMENT_CHARSET_LENGTH)
{
// As some implementations use spaces instead of \0 for the padding,
// we're not so strict and check only the prefix.
if (memcmp(ValuePtr, "ASCII", 5) == 0)
m_ExifInfo->CommentsCharset = EXIF_COMMENT_CHARSET_ASCII;
else if (memcmp(ValuePtr, "UNICODE", 7) == 0)
m_ExifInfo->CommentsCharset = EXIF_COMMENT_CHARSET_UNICODE;
else if (memcmp(ValuePtr, "JIS", 3) == 0)
m_ExifInfo->CommentsCharset = EXIF_COMMENT_CHARSET_JIS;
int length = ByteCount - EXIF_COMMENT_CHARSET_LENGTH;
length = min(length, MAX_COMMENT);
memcpy(m_ExifInfo->Comments, ValuePtr + EXIF_COMMENT_CHARSET_LENGTH, length);
m_ExifInfo->Comments[length] = '\0';
// FixComment(comment); // Ensure comment is printable
}
}
break;
case TAG_XP_COMMENT:
{
// The XP user comment field is always unicode (UCS-2) encoded
m_ExifInfo->XPCommentsCharset = EXIF_COMMENT_CHARSET_UNICODE;
size_t length = min(ByteCount, MAX_COMMENT);
memcpy(m_ExifInfo->XPComment, ValuePtr, length);
m_ExifInfo->XPComment[length] = '\0';
}
break;
case TAG_FNUMBER:
// Simplest way of expressing aperture, so I trust it the most.
// (overwrite previously computd value if there is one)
m_ExifInfo->ApertureFNumber = (float)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_APERTURE:
case TAG_MAXAPERTURE:
// More relevant info always comes earlier, so only use this field if we don't
// have appropriate aperture information yet.
if (m_ExifInfo->ApertureFNumber == 0)
{
m_ExifInfo->ApertureFNumber = (float)exp(ConvertAnyFormat(ValuePtr, Format)*log(2.0)*0.5);
}
break;
case TAG_FOCALLENGTH:
// Nice digital cameras actually save the focal length as a function
// of how far they are zoomed in.
m_ExifInfo->FocalLength = (float)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_SUBJECT_DISTANCE:
// Inidcates the distacne the autofocus camera is focused to.
// Tends to be less accurate as distance increases.
{
float distance = (float)ConvertAnyFormat(ValuePtr, Format);
m_ExifInfo->Distance = distance;
}
break;
case TAG_EXPOSURETIME:
{
// Simplest way of expressing exposure time, so I trust it most.
// (overwrite previously computd value if there is one)
float expTime = (float)ConvertAnyFormat(ValuePtr, Format);
if (expTime)
m_ExifInfo->ExposureTime = expTime;
}
break;
case TAG_SHUTTERSPEED:
// More complicated way of expressing exposure time, so only use
// this value if we don't already have it from somewhere else.
if (m_ExifInfo->ExposureTime == 0)
{
m_ExifInfo->ExposureTime = (float)(1/exp(ConvertAnyFormat(ValuePtr, Format)*log(2.0)));
}
break;
case TAG_FLASH:
m_ExifInfo->FlashUsed = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_ORIENTATION:
m_ExifInfo->Orientation = (int)ConvertAnyFormat(ValuePtr, Format);
if (m_ExifInfo->Orientation < 0 || m_ExifInfo->Orientation > 8)
{
ErrNonfatal("Undefined rotation value %d", m_ExifInfo->Orientation, 0);
m_ExifInfo->Orientation = 0;
}
break;
case TAG_EXIF_IMAGELENGTH:
case TAG_EXIF_IMAGEWIDTH:
// Use largest of height and width to deal with images that have been
// rotated to portrait format.
{
int a = (int)ConvertAnyFormat(ValuePtr, Format);
if (m_ExifImageWidth < a) m_ExifImageWidth = a;
}
break;
case TAG_FOCALPLANEUNITS:
switch((int)ConvertAnyFormat(ValuePtr, Format))
{
// According to the information I was using, 2 means meters.
// But looking at the Cannon powershot's files, inches is the only
// sensible value.
case 1: m_FocalPlaneUnits = 25.4; break; // inch
case 2: m_FocalPlaneUnits = 25.4; break;
case 3: m_FocalPlaneUnits = 10; break; // centimeter
case 4: m_FocalPlaneUnits = 1; break; // millimeter
case 5: m_FocalPlaneUnits = .001; break; // micrometer
}
break;
case TAG_EXPOSURE_BIAS:
m_ExifInfo->ExposureBias = (float)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_WHITEBALANCE:
m_ExifInfo->Whitebalance = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_LIGHT_SOURCE:
//Quercus: 17-1-2004 Added LightSource, some cams return this, whitebalance or both
m_ExifInfo->LightSource = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_METERING_MODE:
m_ExifInfo->MeteringMode = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_EXPOSURE_PROGRAM:
m_ExifInfo->ExposureProgram = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_EXPOSURE_INDEX:
if (m_ExifInfo->ISOequivalent == 0)
{
// Exposure index and ISO equivalent are often used interchangeably,
// so we will do the same.
// http://photography.about.com/library/glossary/bldef_ei.htm
m_ExifInfo->ISOequivalent = (int)ConvertAnyFormat(ValuePtr, Format);
}
break;
case TAG_ISO_EQUIVALENT:
m_ExifInfo->ISOequivalent = (int)ConvertAnyFormat(ValuePtr, Format);
if (m_ExifInfo->ISOequivalent < 50)
m_ExifInfo->ISOequivalent *= 200; // Fixes strange encoding on some older digicams.
break;
case TAG_EXPOSURE_MODE:
m_ExifInfo->ExposureMode = (int)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_DIGITALZOOMRATIO:
m_ExifInfo->DigitalZoomRatio = (float)ConvertAnyFormat(ValuePtr, Format);
break;
case TAG_EXIF_OFFSET:
case TAG_INTEROP_OFFSET:
{
const unsigned char* const SubdirStart = OffsetBase + (unsigned)Get32(ValuePtr, m_MotorolaOrder);
if (SubdirStart < OffsetBase || SubdirStart > OffsetBase+ExifLength)
{
ErrNonfatal("Illegal exif or interop ofset directory link",0,0);
}
else
{
ProcessDir(SubdirStart, OffsetBase, ExifLength, NestingLevel+1);
}
continue;
}
break;
case TAG_GPSINFO:
{
const unsigned char* const SubdirStart = OffsetBase + (unsigned)Get32(ValuePtr, m_MotorolaOrder);
if (SubdirStart < OffsetBase || SubdirStart > OffsetBase+ExifLength)
{
ErrNonfatal("Illegal GPS directory link",0,0);
}
else
{
ProcessGpsInfo(SubdirStart, ByteCount, OffsetBase, ExifLength);
}
continue;
}
break;
case TAG_FOCALLENGTH_35MM:
// The focal length equivalent 35 mm is a 2.2 tag (defined as of April 2002)
// if its present, use it to compute equivalent focal length instead of
// computing it from sensor geometry and actual focal length.
m_ExifInfo->FocalLength35mmEquiv = (unsigned)ConvertAnyFormat(ValuePtr, Format);
break;
}
}
// In addition to linking to subdirectories via exif tags,
// there's also a potential link to another directory at the end of each
// directory. this has got to be the result of a committee!
unsigned Offset;
if (DIR_ENTRY_ADDR(DirStart, NumDirEntries) + 4 <= OffsetBase+ExifLength)
{
Offset = (unsigned)Get32(DirStart+2+12*NumDirEntries, m_MotorolaOrder);
if (Offset)
{
const unsigned char* const SubdirStart = OffsetBase + Offset;
if (SubdirStart > OffsetBase+ExifLength || SubdirStart < OffsetBase)
{
if (SubdirStart > OffsetBase && SubdirStart < OffsetBase+ExifLength+20)
{
// Jhead 1.3 or earlier would crop the whole directory!
// As Jhead produces this form of format incorrectness,
// I'll just let it pass silently
}
else
{
ErrNonfatal("Illegal subdirectory link",0,0);
}
}
else
{
if (SubdirStart <= OffsetBase+ExifLength)
{
ProcessDir(SubdirStart, OffsetBase, ExifLength, NestingLevel+1);
}
}
if (Offset > m_LargestExifOffset)
{
m_LargestExifOffset = Offset;
}
}
}
else
{
// The exif header ends before the last next directory pointer.
}
if (m_ExifInfo->ThumbnailOffset)
{
m_ExifInfo->ThumbnailAtEnd = false;
if (m_ExifInfo->ThumbnailOffset <= ExifLength)
{
if (m_ExifInfo->ThumbnailSize > ExifLength - m_ExifInfo->ThumbnailOffset)
{
// If thumbnail extends past exif header, only save the part that
// actually exists. Canon's EOS viewer utility will do this - the
// thumbnail extracts ok with this hack.
m_ExifInfo->ThumbnailSize = ExifLength - m_ExifInfo->ThumbnailOffset;
}
}
}
}
void _exp(const int N, const float* a,float* y)
{
for(int i=0;i<N;i++) y[i]=exp(a[i]);
}
/* The following function is the very core of the simulation.
* When called, it does the following:-
* Pick a random snake
* Choose which end will be the 'head'
* Choose a random direction for the head to 'move in'
* If that location is not free, return immediately.
* Otherwise, calculated the Energy of the snakes in the new 'shifted' position versus the current configuration.
* Compare this energy shift with an energy randomly pulled from a Boltzmann distribution of temperature/energy
* If energetically favourable, move the snake.
* Otherwise, put the tail back in place
* Return!
*/
void
wriggle ()
{
int s, head, heads, tail;
int dx, dy, dz;
int x, y, z;
double dE = 0.0;
struct coord h, t;
int mat, i;
s = rand_int (num_snakes);
//choose a snake at random
heads = -rand_int (2);
//change this to use dedicated bit random generator
// i.e.heads = 0, -1 with equal prob.
dx = dy = dz = 0;
switch (rand_int (6) + 1)
//choose which of 6 directions to attempt wriggle in
{
case 1:
dx = 1;
break;
case 2:
dx = -1;
break;
case 3:
dy = 1;
break;
case 4:
dy = -1;
break;
case 5:
dz = 1;
break;
case 6:
dz = -1;
break;
}
// fprintf(stderr,"\nWriggle: s: %d\t head: %d\theads: %d\t (dx,dy,dz): %d %d %d\n", s, snakes[s].head, heads, dx, dy, dz);
head = snakes[s].head + heads; //Either choose head1, where the .head points to,
//or the tail/head2 to act as head this time
if (head >= snakes[s].segs) //The Oroborus datatype is circular, so wrap around...
head = 0;
if (head < 0)
head = snakes[s].segs - 1;
// printf("head: %d\t tail:%d\n", head, tail);
x = snakes[s].oroborus[head].x;
y = snakes[s].oroborus[head].y;
z = snakes[s].oroborus[head].z;
if (x + dx < 0 || x + dx >= X
|| y + dy < 0 || y + dy >= Y
|| z + dz < 0 || z + dz >= Z)
return;
//not allowed lattice location !
//The majority of calls to this function will have returned at this point,
// so the above code is stripped to the bare essentials to reach here as quickly as possible
//Now we can calculate other variables necessary to actually move the snake - like the tail location;
if (heads < 0)
tail = head + 1; //tail location before head i.e.going forwards
else
tail = head - 1; //tail location after head i.e.going backwards
if (tail >= snakes[s].segs) //The Oroborus datatype is circular, so wrap around...
tail = 0;
if (tail < 0)
tail = snakes[s].segs - 1;
lattice[snakes[s].oroborus[tail].x]
[snakes[s].oroborus[tail].y][snakes[s].oroborus[tail].z] = -1;
//i.e.Tail moves out of the way first
// This is so that the 'head' can follow the tail around in a closed circle
// I this allows enclosed / boxed-in snakes to 'cycle' around and then escape
if (lattice[x + dx][y + dy][z + dz] == -1)
//gap where head is being forced
// i.e.move is PHYSICALLY possible now need to see whether ENERGETICALLY FAVOURABLE
{
// fprintf(stderr,"Space at: (x,y,z) %d %d %d\n", x + dx, y + dy, z + dz);
//printf("c");
h.x = x + dx; //h is new head location
h.y = y + dy;
h.z = z + dz;
//maybe just copy the pointer to coord ?
t.x = snakes[s].oroborus[tail].x; //t is tail location
t.y = snakes[s].oroborus[tail].y;
t.z = snakes[s].oroborus[tail].z;
dE = 0.0;
for (i = 1; i <= 6; i++)
//all 6 directions
{
dx = dy = dz = 0;
switch (i)
{
case 1:
dx = 1;
break;
case 2:
dx = -1;
break;
case 3:
dy = 1;
break;
case 4:
dy = -1;
break;
case 5:
dz = 1;
break;
case 6:
dz = -1;
break;
}
//NB: Energy change as a result of where the new head is going affect the overall snake positively
//Enthalpy of where the tail used to be affects the overall energy negatively
if (h.x + dx >= 0 && h.x + dx < X // if prospective interaction site within lattice
&& h.y + dy >= 0 && h.y + dy < Y
&& h.z + dz >= 0 && h.z + dz < Z)
{
if (lattice[h.x + dx][h.y + dy][h.z + dz] == -1)
mat = 0; //if empty lattice site material 0[non snake]
else
mat = 1; //if snake material type 1[snake type]
dE += iE[1][mat] - iE[0][mat];
if (lattice[h.x + dx][h.y + dy][h.z + dz] == snakes[s].id) //if touching ourselves
dE += iE[1][mat] - iE[0][mat];
//count energy change twice - once for head
//segment interaction and once for segment head interaction
}
if (t.x + dx >= 0 && t.x + dx < X // if prospective interaction site within lattice
&& t.y + dy >= 0 && t.y + dy < Y
&& t.z + dz >= 0 && t.z + dz < Z)
{
if (lattice[t.x + dx][t.y + dy][t.z + dz] == -1)
mat = 0; //if empty lattice site, material 0[non snake]
else
mat = 1; //if snake material type 1[snake type]
dE += iE[0][mat] - iE[1][mat];
if (lattice[t.x + dx][t.y + dy][t.z + dz] == snakes[s].id)
dE += iE[0][mat] - iE[1][mat];
//if touching ourselves count energy change twice -
//once for head-segment interaction
// and once for segment-head interaction}
}
//SUBSTRATE substrate interactions
if (t.z+dz<0) //added JMF 22-1-07
dE-=500000.0;
if (h.z+dz<0)
dE+=500000.0;
}
// fprintf(stderr, "dE: %f\t", dE);
if (dE > 0.0 || exp(dE * beta) > rand_float ())
//if dE exothermic, reaction progresses automatically
//or if sufficient boltzmann energy to drive endothermic reaction
{
// fprintf(stderr,"Going! (x,y,z) %d %d %d\n",h.x,h.y,h.z);
lattice[h.x][h.y][h.z] = snakes[s].id;
//mark new head location on lattice
// print_lattice();
if (heads < 0)
{
//forwards
snakes[s].head = (tail + 1) % snakes[s].segs;
}
else
snakes[s].head = tail;
snakes[s].oroborus[tail].x = h.x; //tail now becomes new head...
snakes[s].oroborus[tail].y = h.y;
snakes[s].oroborus[tail].z = h.z;
}
else
{
// fprintf(stderr,"Holding!\n");
lattice[snakes[s].oroborus[tail].x]
[snakes[s].oroborus[tail].y]
[snakes[s].oroborus[tail].z] = snakes[s].id;
//i.e.Tail put back in location
}
}
else
{
lattice[snakes[s].oroborus[tail].x]
[snakes[s].oroborus[tail].y]
[snakes[s].oroborus[tail].z] = snakes[s].id;
//i.e.Tail put back in location
// printf("f");
//printf("No space at: (x,y,z) %d %d %d\n", x + dx, y + dy, z + dz);
}
}
double SBMoffat::SBMoffatImpl::kV_15(double ksq) const
{
double k = sqrt(ksq);
return exp(-k);
}
static double gauss_kernel(double diff2, double var)
{
return exp(-diff2 / (2 * var));
}
double SBMoffat::SBMoffatImpl::kV_35(double ksq) const
{
double k = sqrt(ksq);
return exp(-k)*(3.+(3.+k)*k);
}
void
gimp_paint_core_smooth_coords (GimpPaintCore *core,
GimpPaintOptions *paint_options,
GimpCoords *coords)
{
GimpSmoothingOptions *smoothing_options = paint_options->smoothing_options;
GArray *history = core->stroke_buffer;
if (core->stroke_buffer == NULL)
return; /* Paint core has not initalized yet */
if (smoothing_options->use_smoothing &&
smoothing_options->smoothing_quality > 0)
{
gint i;
guint length;
gint min_index;
gdouble gaussian_weight = 0.0;
gdouble gaussian_weight2 = SQR (smoothing_options->smoothing_factor);
gdouble velocity_sum = 0.0;
gdouble scale_sum = 0.0;
g_array_append_val (history, *coords);
if (history->len < 2)
return; /* Just dont bother, nothing to do */
coords->x = coords->y = 0.0;
length = MIN (smoothing_options->smoothing_quality, history->len);
min_index = history->len - length;
if (gaussian_weight2 != 0.0)
gaussian_weight = 1 / (sqrt (2 * G_PI) * smoothing_options->smoothing_factor);
for (i = history->len - 1; i >= min_index; i--)
{
gdouble rate = 0.0;
GimpCoords *next_coords = &g_array_index (history,
GimpCoords, i);
if (gaussian_weight2 != 0.0)
{
/* We use gaussian function with velocity as a window function */
velocity_sum += next_coords->velocity * 100;
rate = gaussian_weight * exp (-velocity_sum * velocity_sum /
(2 * gaussian_weight2));
}
scale_sum += rate;
coords->x += rate * next_coords->x;
coords->y += rate * next_coords->y;
}
if (scale_sum != 0.0)
{
coords->x /= scale_sum;
coords->y /= scale_sum;
}
}
}
// control a dump load that is used when the battery bank is full
// Do a total turbine shutdown if RPMs exceed max value
// make sure that RPMs drop to a safe value before applying brake!
// Also used for last resort overvolt protection
void
run_control(void)
{
// locals
int16_t VoltsHI = 0;
int16_t VoltsLO = 0;
int16_t diff;
uint16_t range = 0;
static bool log_reported = false;
static uint8_t stop_state = RUNNING;
// decide what charging mode we are in.
if (gCharge < (gBankSize * 0.90))
{
charge_mode = BULK;
// only run shunt if volts gets stupidly high!
VoltsHI = gVupper;
VoltsLO = gVupper * 0.98;
}
else if (gCharge < gBankSize)
{
charge_mode = ABSORB;
// start throttling back once over float volts, never go above absorb volts
VoltsHI = gAbsorbVolts;
VoltsLO = gFloatVolts;
}
else
{
charge_mode = FLOAT;
// never go above float volts, but allow a bit of slack
VoltsHI = gFloatVolts;
VoltsLO = (int16_t)((float)gFloatVolts * 0.98);
}
// compensate for temperature - assume set values are for 25C, adjust accordingly
// the higher the temp, the lower the volts by 5mV per deg C
// Tricky calculation as both volts and temperature are scaled by 100
VoltsHI -= 0.005 * (gTemp - 2500);
VoltsLO -= 0.005 * (gTemp - 2500);
// see if we are above shunt load threshold - use instantanious volts, not the average
diff = iVolts - VoltsLO;
if (diff > 0)
{
// see what range we're operating the PWM over
range = VoltsHI - VoltsLO;
// use log application of dump load
#define SHAPE 63
float dval = (float)diff / range;
float fig = log(SHAPE);
float regval = 1010 * (exp(fig * dval) - 1) / (SHAPE - 1);
// if above the top value then set near max on time but make sure its still pulsing
// in case we are using AC coupling!!
if (regval > 1010)
regval = 1010;
OCR1A = (uint16_t) regval;
gDump = regval / 10; // shunt load is activated - show initial value
if (!log_reported && gDump >= 50) // if going from OFF to ON then log the event
{
log_event(LOG_SHUNTON);
log_reported = true;
}
}
else
{
OCR1A = 0;
gDump = 0;
if (log_reported)
{
log_event(LOG_SHUNTOFF);
log_reported = false;
}
}
if (command == MANUALSTOP)
{
stop_state = STOPPING;
command = 0;
}
if (command == MANUALSTART)
{
apply_brake(false);
stop_state = RUNNING;
command = 0;
}
if ((stop_state == STOPPING) && (gRPM < gRPMSafe))
{
apply_brake(true);
stop_state = BREAKING;
}
else if (gRPM > gRPMMax)
{
stop_state = STOPPING;
}
else if ((stop_state == BREAKING) && (gRPM == 0))
{
stop_state = STOPPED;
}
// see if we have an inverter we can control
if (gInverter == 0)
return;
if (command == MANUALOFF)
{
command = 0;
if (ToggleState(ids[gpioid], false))
{
// turned off load OK, start charging
gLoad = LOADOFF;
log_event(LOG_MANUALOFF);
set_charge_target();
}
else
{
// error
log_event(LOG_MANUALOFF | LOG_ERROR);
}
}
// we assume that the user knows what they are doing here!!
// Manual override will run the inverter until the battery hits minimum voltage or manually switched off
if (command == MANUALON)
{
command = 0;
if (ToggleState(ids[gpioid], true))
{
gLoad = LOADON;
log_event(LOG_MANUALON);
// define point to which we discharge to
TargetC = 0;
}
else
{
// error
log_event(LOG_MANUALON | LOG_ERROR);
}
}
// if volts are below set minimum then cut the load whatever the charge state is and start charging again
// this ensures a retry at shutoff in case we get a failure (sticky relay etc)
if (gVolts < gVlower)
{
if (ToggleState(ids[gpioid], false))
{
log_event(LOG_UNDERVOLT);
// turned off load OK, start charging
gLoad = LOADOFF;
TargetC = gBankSize;
}
else
{
//error
log_event(LOG_UNDERVOLT | LOG_ERROR);
}
}
// see if we have an inverter we allow automatic control of
if (gInverter != 2)
return;
// the load is not on
if (gLoad == LOADOFF)
{
// if volts is above the set maximum apply load to try and pull the volts down - leave load on for only a short while
if (gVolts > gVupper)
{
if (ToggleState(ids[gpioid], true))
{
// turn on load
gLoad = LOADON;
log_event(LOG_OVERVOLT);
// set the target level to discharge to a small amount below the current value so we don't keep the load on for too long
TargetC = (int16_t)((float)gCharge * 0.99);
}
else
{
//error
log_event(LOG_OVERVOLT | LOG_ERROR);
}
}
// if we have reached our target charge level then start normal discharge cycle
else if (gCharge >= TargetC)
{
if (ToggleState(ids[gpioid], true))
{
// turn on load
gLoad = LOADAUTO;
log_event(LOG_CHARGED);
TargetC = gMinCharge;
}
else
{
// error
log_event(LOG_CHARGED | LOG_ERROR);
}
}
}
// the load is already on or auto
else
{
// if we have reached our target discharge level then start normal charge cycle
if (gCharge <= TargetC)
{
if (ToggleState(ids[gpioid], false))
{
// turned off load OK, start charging
gLoad = LOADOFF;
log_event(LOG_DISCHARGED);
// decide whether we are doing a normal charge or we are taking up to full float level
set_charge_target();
eeprom_write_block ((const void *) &gDischarge, (void *) &eeDischarge, sizeof(gDischarge));
}
else
{
// error
log_event(LOG_DISCHARGED | LOG_ERROR);
}
}
}
}
void evaluation_data()
{
QTest::addColumn<QString>( "string" );
QTest::addColumn<bool>( "evalError" );
QTest::addColumn<QVariant>( "result" );
// literal evaluation
QTest::newRow( "literal null" ) << "NULL" << false << QVariant();
QTest::newRow( "literal int" ) << "123" << false << QVariant( 123 );
QTest::newRow( "literal double" ) << "1.2" << false << QVariant( 1.2 );
QTest::newRow( "literal text" ) << "'hello'" << false << QVariant( "hello" );
QTest::newRow( "literal double" ) << ".000001" << false << QVariant( 0.000001 );
QTest::newRow( "literal double" ) << "1.0e-6" << false << QVariant( 0.000001 );
QTest::newRow( "literal double" ) << "1e-6" << false << QVariant( 0.000001 );
// unary minus
QTest::newRow( "unary minus double" ) << "-1.3" << false << QVariant( -1.3 );
QTest::newRow( "unary minus int" ) << "-1" << false << QVariant( -1 );
QTest::newRow( "unary minus text" ) << "-'hello'" << true << QVariant();
QTest::newRow( "unary minus null" ) << "-null" << true << QVariant();
// arithmetics
QTest::newRow( "plus int" ) << "1+3" << false << QVariant( 4 );
QTest::newRow( "plus double" ) << "1+1.3" << false << QVariant( 2.3 );
QTest::newRow( "plus with null" ) << "null+3" << false << QVariant();
QTest::newRow( "plus invalid" ) << "1+'foo'" << true << QVariant();
QTest::newRow( "minus int" ) << "1-3" << false << QVariant( -2 );
QTest::newRow( "mul int" ) << "8*7" << false << QVariant( 56 );
QTest::newRow( "div int" ) << "20/6" << false << QVariant( 3 );
QTest::newRow( "mod int" ) << "20%6" << false << QVariant( 2 );
QTest::newRow( "minus double" ) << "5.2-3.1" << false << QVariant( 2.1 );
QTest::newRow( "mul double" ) << "2.1*5" << false << QVariant( 10.5 );
QTest::newRow( "div double" ) << "11.0/2" << false << QVariant( 5.5 );
QTest::newRow( "mod double" ) << "6.1 % 2.5" << false << QVariant( 1.1 );
QTest::newRow( "pow" ) << "2^8" << false << QVariant( 256. );
QTest::newRow( "division by zero" ) << "1/0" << false << QVariant();
QTest::newRow( "division by zero" ) << "1.0/0.0" << false << QVariant();
// comparison
QTest::newRow( "eq int" ) << "1+1 = 2" << false << QVariant( 1 );
QTest::newRow( "eq double" ) << "3.2 = 2.2+1" << false << QVariant( 1 );
QTest::newRow( "eq string" ) << "'a' = 'b'" << false << QVariant( 0 );
QTest::newRow( "eq null" ) << "2 = null" << false << QVariant();
QTest::newRow( "eq mixed" ) << "'a' = 1" << false << QVariant( 0 );
QTest::newRow( "ne int 1" ) << "3 != 4" << false << QVariant( 1 );
QTest::newRow( "ne int 2" ) << "3 != 3" << false << QVariant( 0 );
QTest::newRow( "lt int 1" ) << "3 < 4" << false << QVariant( 1 );
QTest::newRow( "lt int 2" ) << "3 < 3" << false << QVariant( 0 );
QTest::newRow( "gt int 1" ) << "3 > 4" << false << QVariant( 0 );
QTest::newRow( "gt int 2" ) << "3 > 3" << false << QVariant( 0 );
QTest::newRow( "le int 1" ) << "3 <= 4" << false << QVariant( 1 );
QTest::newRow( "le int 2" ) << "3 <= 3" << false << QVariant( 1 );
QTest::newRow( "ge int 1" ) << "3 >= 4" << false << QVariant( 0 );
QTest::newRow( "ge int 2" ) << "3 >= 3" << false << QVariant( 1 );
QTest::newRow( "lt text 1" ) << "'bar' < 'foo'" << false << QVariant( 1 );
QTest::newRow( "lt text 2" ) << "'foo' < 'bar'" << false << QVariant( 0 );
// is, is not
QTest::newRow( "is null,null" ) << "null is null" << false << QVariant( 1 );
QTest::newRow( "is not null,null" ) << "null is not null" << false << QVariant( 0 );
QTest::newRow( "is null" ) << "1 is null" << false << QVariant( 0 );
QTest::newRow( "is not null" ) << "1 is not null" << false << QVariant( 1 );
QTest::newRow( "is int" ) << "1 is 1" << false << QVariant( 1 );
QTest::newRow( "is not int" ) << "1 is not 1" << false << QVariant( 0 );
QTest::newRow( "is text" ) << "'x' is 'y'" << false << QVariant( 0 );
QTest::newRow( "is not text" ) << "'x' is not 'y'" << false << QVariant( 1 );
// logical
QTest::newRow( "T or F" ) << "1=1 or 2=3" << false << QVariant( 1 );
QTest::newRow( "F or F" ) << "1=2 or 2=3" << false << QVariant( 0 );
QTest::newRow( "T and F" ) << "1=1 and 2=3" << false << QVariant( 0 );
QTest::newRow( "T and T" ) << "1=1 and 2=2" << false << QVariant( 1 );
QTest::newRow( "not T" ) << "not 1=1" << false << QVariant( 0 );
QTest::newRow( "not F" ) << "not 2=3" << false << QVariant( 1 );
QTest::newRow( "null" ) << "null=1" << false << QVariant();
QTest::newRow( "U or F" ) << "null=1 or 2=3" << false << QVariant();
QTest::newRow( "U and F" ) << "null=1 and 2=3" << false << QVariant( 0 );
QTest::newRow( "invalid and" ) << "'foo' and 2=3" << true << QVariant();
QTest::newRow( "invalid or" ) << "'foo' or 2=3" << true << QVariant();
QTest::newRow( "invalid not" ) << "not 'foo'" << true << QVariant();
// in, not in
QTest::newRow( "in 1" ) << "1 in (1,2,3)" << false << QVariant( 1 );
QTest::newRow( "in 2" ) << "1 in (1,null,3)" << false << QVariant( 1 );
QTest::newRow( "in 3" ) << "1 in (null,2,3)" << false << QVariant();
QTest::newRow( "in 4" ) << "null in (1,2,3)" << false << QVariant();
QTest::newRow( "not in 1" ) << "1 not in (1,2,3)" << false << QVariant( 0 );
QTest::newRow( "not in 2" ) << "1 not in (1,null,3)" << false << QVariant( 0 );
QTest::newRow( "not in 3" ) << "1 not in (null,2,3)" << false << QVariant();
QTest::newRow( "not in 4" ) << "null not in (1,2,3)" << false << QVariant();
// regexp, like
QTest::newRow( "like 1" ) << "'hello' like '%ll_'" << false << QVariant( 1 );
QTest::newRow( "like 2" ) << "'hello' like 'lo'" << false << QVariant( 0 );
QTest::newRow( "like 3" ) << "'hello' like '%LO'" << false << QVariant( 0 );
QTest::newRow( "ilike" ) << "'hello' ilike '%LO'" << false << QVariant( 1 );
QTest::newRow( "regexp 1" ) << "'hello' ~ 'll'" << false << QVariant( 1 );
QTest::newRow( "regexp 2" ) << "'hello' ~ '^ll'" << false << QVariant( 0 );
QTest::newRow( "regexp 3" ) << "'hello' ~ 'llo$'" << false << QVariant( 1 );
// concatenation
QTest::newRow( "concat with plus" ) << "'a' + 'b'" << false << QVariant( "ab" );
QTest::newRow( "concat" ) << "'a' || 'b'" << false << QVariant( "ab" );
QTest::newRow( "concat with int" ) << "'a' || 1" << false << QVariant( "a1" );
QTest::newRow( "concat with int" ) << "2 || 'b'" << false << QVariant( "2b" );
QTest::newRow( "concat with null" ) << "'a' || null" << false << QVariant();
QTest::newRow( "concat numbers" ) << "1 || 2" << false << QVariant( "12" );
// math functions
QTest::newRow( "sqrt" ) << "sqrt(16)" << false << QVariant( 4. );
QTest::newRow( "abs(0.1)" ) << "abs(0.1)" << false << QVariant( 0.1 );
QTest::newRow( "abs(0)" ) << "abs(0)" << false << QVariant( 0. );
QTest::newRow( "abs(-0.1)" ) << "abs(-0.1)" << false << QVariant( 0.1 );
QTest::newRow( "invalid sqrt value" ) << "sqrt('a')" << true << QVariant();
QTest::newRow( "sin 0" ) << "sin(0)" << false << QVariant( 0. );
QTest::newRow( "cos 0" ) << "cos(0)" << false << QVariant( 1. );
QTest::newRow( "tan 0" ) << "tan(0)" << false << QVariant( 0. );
QTest::newRow( "asin 0" ) << "asin(0)" << false << QVariant( 0. );
QTest::newRow( "acos 1" ) << "acos(1)" << false << QVariant( 0. );
QTest::newRow( "atan 0" ) << "atan(0)" << false << QVariant( 0. );
QTest::newRow( "atan2(0,1)" ) << "atan2(0,1)" << false << QVariant( 0. );
QTest::newRow( "atan2(1,0)" ) << "atan2(1,0)" << false << QVariant( M_PI / 2 );
QTest::newRow( "exp(0)" ) << "exp(0)" << false << QVariant( 1. );
QTest::newRow( "exp(1)" ) << "exp(1)" << false << QVariant( exp( 1. ) );
QTest::newRow( "ln(0)" ) << "ln(0)" << false << QVariant();
QTest::newRow( "log10(-1)" ) << "log10(-1)" << false << QVariant();
QTest::newRow( "ln(1)" ) << "ln(1)" << false << QVariant( log( 1. ) );
QTest::newRow( "log10(100)" ) << "log10(100)" << false << QVariant( 2. );
QTest::newRow( "log(2,32)" ) << "log(2,32)" << false << QVariant( 5. );
QTest::newRow( "log(10,1000)" ) << "log(10,1000)" << false << QVariant( 3. );
QTest::newRow( "log(-2,32)" ) << "log(-2,32)" << false << QVariant();
QTest::newRow( "log(2,-32)" ) << "log(2,-32)" << false << QVariant();
QTest::newRow( "log(0.5,32)" ) << "log(0.5,32)" << false << QVariant( -5. );
QTest::newRow( "round(1234.557,2) - round up" ) << "round(1234.557,2)" << false << QVariant( 1234.56 );
QTest::newRow( "round(1234.554,2) - round down" ) << "round(1234.554,2)" << false << QVariant( 1234.55 );
QTest::newRow( "round(1234.6) - round up to int" ) << "round(1234.6)" << false << QVariant( 1235 );
QTest::newRow( "round(1234.6) - round down to int" ) << "round(1234.4)" << false << QVariant( 1234 );
QTest::newRow( "max(1)" ) << "max(1)" << false << QVariant( 1. );
QTest::newRow( "max(1,3.5,-2.1)" ) << "max(1,3.5,-2.1)" << false << QVariant( 3.5 );
QTest::newRow( "min(-1.5)" ) << "min(-1.5)" << false << QVariant( -1.5 );
QTest::newRow( "min(-16.6,3.5,-2.1)" ) << "min(-16.6,3.5,-2.1)" << false << QVariant( -16.6 );
QTest::newRow( "clamp(-2,1,5)" ) << "clamp(-2,1,5)" << false << QVariant( 1.0 );
QTest::newRow( "clamp(-2,-10,5)" ) << "clamp(-2,-10,5)" << false << QVariant( -2.0 );
QTest::newRow( "clamp(-2,100,5)" ) << "clamp(-2,100,5)" << false << QVariant( 5.0 );
QTest::newRow( "floor(4.9)" ) << "floor(4.9)" << false << QVariant( 4. );
QTest::newRow( "floor(-4.9)" ) << "floor(-4.9)" << false << QVariant( -5. );
QTest::newRow( "ceil(4.9)" ) << "ceil(4.9)" << false << QVariant( 5. );
QTest::newRow( "ceil(-4.9)" ) << "ceil(-4.9)" << false << QVariant( -4. );
QTest::newRow( "scale_linear(0.5,0,1,0,1)" ) << "scale_linear(0.5,0,1,0,1)" << false << QVariant( 0.5 );
QTest::newRow( "scale_linear(0,0,10,100,200)" ) << "scale_linear(0,0,10,100,200)" << false << QVariant( 100. );
QTest::newRow( "scale_linear(5,0,10,100,200)" ) << "scale_linear(5,0,10,100,200)" << false << QVariant( 150. );
QTest::newRow( "scale_linear(10,0,10,100,200)" ) << "scale_linear(10,0,10,100,200)" << false << QVariant( 200. );
QTest::newRow( "scale_linear(-1,0,10,100,200)" ) << "scale_linear(-1,0,10,100,200)" << false << QVariant( 100. );
QTest::newRow( "scale_linear(11,0,10,100,200)" ) << "scale_linear(11,0,10,100,200)" << false << QVariant( 200. );
QTest::newRow( "scale_exp(0.5,0,1,0,1,2)" ) << "scale_exp(0.5,0,1,0,1,2)" << false << QVariant( 0.25 );
QTest::newRow( "scale_exp(0,0,10,100,200,2)" ) << "scale_exp(0,0,10,100,200,2)" << false << QVariant( 100. );
QTest::newRow( "scale_exp(5,0,10,100,200,2)" ) << "scale_exp(5,0,10,100,200,2)" << false << QVariant( 125. );
QTest::newRow( "scale_exp(10,0,10,100,200,0.5)" ) << "scale_exp(10,0,10,100,200,0.5)" << false << QVariant( 200. );
QTest::newRow( "scale_exp(-1,0,10,100,200,0.5)" ) << "scale_exp(-1,0,10,100,200,0.5)" << false << QVariant( 100. );
QTest::newRow( "scale_exp(4,0,9,0,90,0.5)" ) << "scale_exp(4,0,9,0,90,0.5)" << false << QVariant( 60. );
// cast functions
QTest::newRow( "double to int" ) << "toint(3.2)" << false << QVariant( 3 );
QTest::newRow( "text to int" ) << "toint('53')" << false << QVariant( 53 );
QTest::newRow( "null to int" ) << "toint(null)" << false << QVariant();
QTest::newRow( "int to double" ) << "toreal(3)" << false << QVariant( 3. );
QTest::newRow( "text to double" ) << "toreal('53.1')" << false << QVariant( 53.1 );
QTest::newRow( "null to double" ) << "toreal(null)" << false << QVariant();
QTest::newRow( "int to text" ) << "tostring(6)" << false << QVariant( "6" );
QTest::newRow( "double to text" ) << "tostring(1.23)" << false << QVariant( "1.23" );
QTest::newRow( "null to text" ) << "tostring(null)" << false << QVariant();
// string functions
QTest::newRow( "lower" ) << "lower('HeLLo')" << false << QVariant( "hello" );
QTest::newRow( "upper" ) << "upper('HeLLo')" << false << QVariant( "HELLO" );
QTest::newRow( "length" ) << "length('HeLLo')" << false << QVariant( 5 );
QTest::newRow( "replace" ) << "replace('HeLLo', 'LL', 'xx')" << false << QVariant( "Hexxo" );
QTest::newRow( "regexp_replace" ) << "regexp_replace('HeLLo','[eL]+', '-')" << false << QVariant( "H-o" );
QTest::newRow( "regexp_replace invalid" ) << "regexp_replace('HeLLo','[[[', '-')" << true << QVariant();
QTest::newRow( "substr" ) << "substr('HeLLo', 3,2)" << false << QVariant( "LL" );
QTest::newRow( "substr outside" ) << "substr('HeLLo', -5,2)" << false << QVariant( "" );
QTest::newRow( "regexp_substr" ) << "regexp_substr('abc123','(\\\\d+)')" << false << QVariant( "123" );
QTest::newRow( "regexp_substr invalid" ) << "regexp_substr('abc123','([[[')" << true << QVariant();
QTest::newRow( "strpos" ) << "strpos('Hello World','World')" << false << QVariant( 6 );
QTest::newRow( "strpos outside" ) << "strpos('Hello World','blah')" << false << QVariant( -1 );
QTest::newRow( "left" ) << "left('Hello World',5)" << false << QVariant( "Hello" );
QTest::newRow( "right" ) << "right('Hello World', 5)" << false << QVariant( "World" );
QTest::newRow( "rpad" ) << "rpad('Hello', 10, 'x')" << false << QVariant( "Helloxxxxx" );
QTest::newRow( "rpad truncate" ) << "rpad('Hello', 4, 'x')" << false << QVariant( "Hell" );
QTest::newRow( "lpad" ) << "lpad('Hello', 10, 'x')" << false << QVariant( "xxxxxHello" );
QTest::newRow( "lpad truncate" ) << "rpad('Hello', 4, 'x')" << false << QVariant( "Hell" );
QTest::newRow( "title" ) << "title(' HeLlO WORLD ')" << false << QVariant( " Hello World " );
QTest::newRow( "trim" ) << "trim(' Test String ')" << false << QVariant( "Test String" );
QTest::newRow( "trim empty string" ) << "trim('')" << false << QVariant( "" );
QTest::newRow( "wordwrap" ) << "wordwrap('university of qgis',13)" << false << QVariant( "university of\nqgis" );
QTest::newRow( "wordwrap" ) << "wordwrap('university of qgis',13,' ')" << false << QVariant( "university of\nqgis" );
QTest::newRow( "wordwrap" ) << "wordwrap('university of qgis',-3)" << false << QVariant( "university\nof qgis" );
QTest::newRow( "wordwrap" ) << "wordwrap('university of qgis',-3,' ')" << false << QVariant( "university\nof qgis" );
QTest::newRow( "wordwrap" ) << "wordwrap('university of qgis\nsupports many multiline',-5,' ')" << false << QVariant( "university\nof qgis\nsupports\nmany multiline" );
QTest::newRow( "format" ) << "format('%1 %2 %3 %1', 'One', 'Two', 'Three')" << false << QVariant( "One Two Three One" );
// implicit conversions
QTest::newRow( "implicit int->text" ) << "length(123)" << false << QVariant( 3 );
QTest::newRow( "implicit double->text" ) << "length(1.23)" << false << QVariant( 4 );
QTest::newRow( "implicit int->bool" ) << "1 or 0" << false << QVariant( 1 );
QTest::newRow( "implicit double->bool" ) << "0.1 or 0" << false << QVariant( 1 );
QTest::newRow( "implicit text->int" ) << "'5'+2" << false << QVariant( 7 );
QTest::newRow( "implicit text->double" ) << "'5.1'+2" << false << QVariant( 7.1 );
QTest::newRow( "implicit text->bool" ) << "'0.1' or 0" << false << QVariant( 1 );
// conditions (without base expression, i.e. CASE WHEN ... THEN ... END)
QTest::newRow( "condition when" ) << "case when 2>1 then 'good' end" << false << QVariant( "good" );
QTest::newRow( "condition else" ) << "case when 1=0 then 'bad' else 678 end" << false << QVariant( 678 );
QTest::newRow( "condition null" ) << "case when length(123)=0 then 111 end" << false << QVariant();
QTest::newRow( "condition 2 when" ) << "case when 2>3 then 23 when 3>2 then 32 else 0 end" << false << QVariant( 32 );
QTest::newRow( "coalesce null" ) << "coalesce(NULL)" << false << QVariant();
QTest::newRow( "coalesce mid-null" ) << "coalesce(1, NULL, 3)" << false << QVariant( 1 );
QTest::newRow( "coalesce exp" ) << "coalesce(NULL, 1+1)" << false << QVariant( 2 );
QTest::newRow( "regexp match" ) << "regexp_match('abc','.b.')" << false << QVariant( 1 );
QTest::newRow( "regexp match invalid" ) << "regexp_match('abc DEF','[[[')" << true << QVariant();
QTest::newRow( "regexp match escaped" ) << "regexp_match('abc DEF','\\\\s[A-Z]+')" << false << QVariant( 1 );
QTest::newRow( "regexp match false" ) << "regexp_match('abc DEF','\\\\s[a-z]+')" << false << QVariant( 0 );
// Datetime functions
QTest::newRow( "to date" ) << "todate('2012-06-28')" << false << QVariant( QDate( 2012, 6, 28 ) );
QTest::newRow( "to interval" ) << "tointerval('1 Year 1 Month 1 Week 1 Hour 1 Minute')" << false << QVariant::fromValue( QgsExpression::Interval( 34758060 ) );
QTest::newRow( "day with date" ) << "day('2012-06-28')" << false << QVariant( 28 );
QTest::newRow( "day with interval" ) << "day(tointerval('28 days'))" << false << QVariant( 28.0 );
QTest::newRow( "month with date" ) << "month('2012-06-28')" << false << QVariant( 6 );
QTest::newRow( "month with interval" ) << "month(tointerval('2 months'))" << false << QVariant( 2.0 );
QTest::newRow( "year with date" ) << "year('2012-06-28')" << false << QVariant( 2012 );
QTest::newRow( "year with interval" ) << "year(tointerval('2 years'))" << false << QVariant( 2.0 );
QTest::newRow( "age" ) << "age('2012-06-30','2012-06-28')" << false << QVariant::fromValue( QgsExpression::Interval( 172800 ) );
QTest::newRow( "negative age" ) << "age('2012-06-28','2012-06-30')" << false << QVariant::fromValue( QgsExpression::Interval( -172800 ) );
// Color functions
QTest::newRow( "ramp color" ) << "ramp_color('Spectral',0.3)" << false << QVariant( "253,190,115,255" );
QTest::newRow( "color rgb" ) << "color_rgb(255,127,0)" << false << QVariant( "255,127,0" );
QTest::newRow( "color rgba" ) << "color_rgba(255,127,0,200)" << false << QVariant( "255,127,0,200" );
QTest::newRow( "color hsl" ) << "color_hsl(100,50,70)" << false << QVariant( "166,217,140" );
QTest::newRow( "color hsla" ) << "color_hsla(100,50,70,200)" << false << QVariant( "166,217,140,200" );
QTest::newRow( "color hsv" ) << "color_hsv(40,100,100)" << false << QVariant( "255,170,0" );
QTest::newRow( "color hsva" ) << "color_hsva(40,100,100,200)" << false << QVariant( "255,170,0,200" );
QTest::newRow( "color cmyk" ) << "color_cmyk(100,50,33,10)" << false << QVariant( "0,115,154" );
QTest::newRow( "color cmyka" ) << "color_cmyka(50,25,90,60,200)" << false << QVariant( "51,76,10,200" );
}
void main(void)\n\
{ \n\
float fTime0_X = parameters[0][0];\n\
vec4 coreSeed = parameters[1];\n\
\n\
vec3 rayDir = normalize(objectPosition * vec3(1.0, 0.6, 1.0));\n\
vec3 camPos = vec3(0.0, 0.0, -parameters[0][1]);\n\
\n\
// rotate camera around y axis\n\
float alpha = parameters[0][2] * 4.5f;\n\
camPos.xz = vec2(cos(alpha)*camPos.x - sin(alpha)*camPos.z,\n\
sin(alpha)*camPos.x + cos(alpha)*camPos.z);\n\
rayDir.xz = vec2(cos(alpha)*rayDir.x - sin(alpha)*rayDir.z,\n\
sin(alpha)*rayDir.x + cos(alpha)*rayDir.z);\n\
\n\
vec3 rayPos = camPos;\n\
float sceneSize = 8.0;\n\
vec3 totalColor = vec3(0.);\n\
float stepSize;\n\
float totalDensity = 0.0;\n\
float stepDepth = 0.0; // how far I went already.\n\
\n\
for(int step = 0; length(rayPos)<sceneSize && totalDensity < 0.9 && step < 50; step++)\n\
{ \n\
float implicitVal;\n\
\n\
// This stuff is the transformation information from previous stuff\n\
float transer = parameters[0][3];\n\
vec4 prevQuaternion = vec4(cos(transer), sin(transer), sin(transer * 1.3), sin(transer * 2.7));\n\
prevQuaternion = normalize(prevQuaternion);\n\
float prevLength = 1.0;\n\
vec3 prevMover = vec3(0.0);\n\
vec3 prevColor = vec3(1.0, 0.4, 0.2);\n\
\n\
// Multiple boxes\n\
implicitVal = 1.0e10;\n\
\n\
for (int loop = 0; loop < 12; loop++)\n\
{\n\
vec4 newQuaternion;\n\
float newLength;\n\
vec3 newMover;\n\
vec3 newColor;\n\
\n\
mat3 prevRotationMatrix = quaternionToMatrix(prevQuaternion);\n\
\n\
// Loop for solid stuff\n\
vec4 seed = coreSeed;\n\
for (int k = 0; k < 4; k++)\n\
{\n\
seed = randomIteration(seed);\n\
vec4 quaternion = normalize(seed - vec4(0.5));\n\
mat3 rotationMatrix = quaternionToMatrix(quatMult(quaternion, prevQuaternion));\n\
vec3 lengthes = seed.xyz * seed.xyz * seed.xyz * seed.xyz * vec3(0.2) + vec3(0.05);\n\
lengthes *= prevLength;\n\
vec3 mover = 0.5*seed.wzx - vec3(0.25);\n\
mover = (mover * prevRotationMatrix * prevLength) + prevMover;\n\
float curImplicitVal = getDistance(rotationMatrix, lengthes, mover, rayPos);\n\
implicitVal = min(implicitVal, curImplicitVal);\n\
}\n\
\n\
// Non-solid:\n\
float nonSolidDist = 1.0e10;\n\
for (int k = 0; k < 2; k++)\n\
{\n\
seed = randomIteration(seed);\n\
vec4 quaternion = normalize(seed - vec4(0.5));\n\
quaternion = quatMult(quaternion, prevQuaternion);\n\
vec3 lengthes = seed.xyz * vec3(0.3) + vec3(0.25);\n\
lengthes *= prevLength;\n\
vec3 mover = 0.5*seed.wzx - vec3(0.25);\n\
mover = (mover * prevRotationMatrix * prevLength) + prevMover;\n\
float curImplicitVal = getSphereDistance(lengthes.x, mover, rayPos);\n\
if (curImplicitVal < nonSolidDist)\n\
{\n\
nonSolidDist = curImplicitVal;\n\
newQuaternion = quaternion;\n\
newLength = lengthes.x;\n\
newMover = mover;\n\
newColor = seed.xyz;\n\
}\n\
}\n\
\n\
if (nonSolidDist > implicitVal)\n\
{\n\
// I will not get closer than where I am now.\n\
break;\n\
}\n\
else\n\
{\n\
prevQuaternion = newQuaternion;\n\
prevLength = newLength;\n\
prevMover = newMover;\n\
prevColor = 0.5 * prevColor + 0.5 * newColor; \n\
}\n\
}\n\
\n\
// I need to do this distance related to for the DOF! \n\
totalColor += vec3(1./50., 1./70., 1./90.) *\n\
1.7 / exp(abs(implicitVal*5.) + 0.0) * 1.8;\n\
totalDensity += 1./ 15. / exp(abs(implicitVal*10.0) + 0.5);\n\
// *(1.0 - cos(fTime0_X*3.)*0.5);\n\
//if (implicitVal < 0.0)\n\
stepDepth += abs(implicitVal) * 0.95; \n\
{\n\
// TODO: I could make this distance-related, with offset to get the size right?\n\
float localDensity = implicitVal < 0.0 ? 1.0 : 0.0;\n\
totalColor = totalColor + (1.-totalDensity) * prevColor * localDensity;\n\
totalDensity = totalDensity + (1.05-totalDensity) * localDensity;\n\
}\n\
\n\
stepSize = abs(implicitVal) * 0.99;\n\
stepSize = max(0.005 * stepDepth, stepSize);\n\
rayPos += rayDir * stepSize;\n\
}\n\
\n\
float grad = normalize(rayDir).y;\n\
totalColor += (1.-totalDensity) * (grad * vec3(0.0,-0.4,-0.3) + (1.-grad)*vec3(0.0,0.4,0.6));\n\
\n\
gl_FragColor = vec4(totalColor-vec3(0.0), 1.0);\n\
}\n\
static void
psdflp_do(const PSDFLPArgs *args, GwyDataField *dfield, GwyDataField *lpsdf)
{
enum { N = 4 };
GwyDataField *reout, *imout;
gint pxres, pyres, fxres, fyres;
gint i, j, fi, pi;
gdouble *ldata, *redata, *imdata;
gdouble *cosphi, *sinphi;
gdouble xreal, yreal, f0, f_max, b, p;
reout = gwy_data_field_new_alike(dfield, FALSE);
imout = gwy_data_field_new_alike(dfield, FALSE);
gwy_data_field_2dfft(dfield, NULL, reout, imout,
args->window, GWY_TRANSFORM_DIRECTION_FORWARD,
GWY_INTERPOLATION_ROUND, /* Ignored */
TRUE, 1);
pxres = reout->xres;
pyres = reout->yres;
redata = gwy_data_field_get_data(reout);
imdata = gwy_data_field_get_data(imout);
for (i = 0; i < pxres*pyres; i++)
redata[i] = redata[i]*redata[i] + imdata[i]*imdata[i];
gwy_data_field_2dfft_humanize(reout);
gwy_data_field_filter_gaussian(reout, args->sigma);
for (i = 0; i < pxres*pyres; i++)
redata[i] = sqrt(redata[i]);
fxres = pxres/2;
fyres = pyres/2;
gwy_data_field_resample(lpsdf, fxres, fyres, GWY_INTERPOLATION_NONE);
ldata = gwy_data_field_get_data(lpsdf);
xreal = dfield->xreal;
yreal = dfield->yreal;
f0 = 2.0/MIN(xreal, yreal);
f_max = 0.5*MIN(pxres/xreal, pyres/yreal);
if (f_max <= f0) {
g_warning("Minimum frequency is not smaller than maximum frequency.");
}
b = log(f_max/f0)/fyres;
/* Incorporate some prefactors to sinphi[] and cosphi[], knowing that
* cosine is only ever used for x and sine for y frequencies. */
cosphi = g_new(gdouble, (N+1)*fxres);
sinphi = g_new(gdouble, (N+1)*fxres);
for (j = 0; j < fxres; j++) {
gdouble phi_from = 2.0*G_PI*j/fxres;
gdouble phi_to = 2.0*G_PI*(j + 1.0)/fxres;
for (pi = 0; pi <= N; pi++) {
gdouble phi = ((pi + 0.5)*phi_from + (N - 0.5 - pi)*phi_to)/N;
cosphi[j*(N+1) + pi] = cos(phi)*xreal;
sinphi[j*(N+1) + pi] = sin(phi)*yreal;
}
}
for (i = 0; i < fyres; i++) {
gdouble f_from = f0*exp(b*i);
gdouble f_to = f0*exp(b*(i + 1.0));
for (j = 0; j < fxres; j++) {
const gdouble *cosphi_j = cosphi + j*(N+1);
const gdouble *sinphi_j = sinphi + j*(N+1);
guint n = 0;
gdouble s = 0.0;
for (fi = 0; fi <= N; fi++) {
gdouble f = ((fi + 0.5)*f_from + (N - 0.5 - fi)*f_to)/N;
for (pi = 0; pi <= N; pi++) {
gdouble x = f*cosphi_j[pi] + pxres/2.0,
y = f*sinphi_j[pi] + pyres/2.0;
if (G_UNLIKELY(x < 0.5
|| y < 0.5
|| x > pxres - 1.5
|| y > pyres - 1.5))
continue;
p = gwy_data_field_get_dval(reout, x, y,
GWY_INTERPOLATION_SCHAUM);
s += p;
n++;
}
}
if (!n)
n = 1;
ldata[i*fxres + j] = 2.0*G_PI/fxres * s/n*(f_to - f_from);
}
}
g_object_unref(imout);
g_object_unref(reout);
gwy_data_field_set_xreal(lpsdf, 2.0*G_PI);
gwy_data_field_set_xoffset(lpsdf, 0.0);
gwy_data_field_set_yreal(lpsdf, log(f_max/f0));
gwy_data_field_set_yoffset(lpsdf, log(f0));
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(lpsdf), "");
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(lpsdf), "");
gwy_data_field_normalize(lpsdf);
}
Float_t EtaToTheta(Float_t arg){
return (180./TMath::Pi())*2.*atan(exp(-arg));
}
F32 ScatterSky::_vernierScale( F32 fCos )
{
F32 x = 1.0 - fCos;
return 0.25f * exp( -0.00287f + x * (0.459f + x * (3.83f + x * ((-6.80f + (x * 5.25f))))) );
}
int DetectionOutput::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs) const
{
const Mat& location = bottom_blobs[0];
const Mat& confidence = bottom_blobs[1];
const Mat& priorbox = bottom_blobs[2];
const int num_prior = priorbox.w / 4;
// apply location with priorbox
Mat bboxes;
bboxes.create(4, num_prior);
if (bboxes.empty())
return -100;
const float* location_ptr = location;
const float* priorbox_ptr = priorbox.row(0);
const float* variance_ptr = priorbox.row(1);
#pragma omp parallel for
for (int i = 0; i < num_prior; i++)
{
const float* loc = location_ptr + i * 4;
const float* pb = priorbox_ptr + i * 4;
const float* var = variance_ptr + i * 4;
float* bbox = bboxes.row(i);
// CENTER_SIZE
float pb_w = pb[2] - pb[0];
float pb_h = pb[3] - pb[1];
float pb_cx = (pb[0] + pb[2]) * 0.5f;
float pb_cy = (pb[1] + pb[3]) * 0.5f;
float bbox_cx = var[0] * loc[0] * pb_w + pb_cx;
float bbox_cy = var[1] * loc[1] * pb_h + pb_cy;
float bbox_w = exp(var[2] * loc[2]) * pb_w;
float bbox_h = exp(var[3] * loc[3]) * pb_h;
bbox[0] = bbox_cx - bbox_w * 0.5f;
bbox[1] = bbox_cy - bbox_h * 0.5f;
bbox[2] = bbox_cx + bbox_w * 0.5f;
bbox[3] = bbox_cy + bbox_h * 0.5f;
}
// sort and nms for each class
std::vector< std::vector<BBoxRect> > all_class_bbox_rects;
std::vector< std::vector<float> > all_class_bbox_scores;
all_class_bbox_rects.resize(num_class);
all_class_bbox_scores.resize(num_class);
// start from 1 to ignore background class
#pragma omp parallel for
for (int i = 1; i < num_class; i++)
{
// filter by confidence_threshold
std::vector<BBoxRect> class_bbox_rects;
std::vector<float> class_bbox_scores;
for (int j = 0; j < num_prior; j++)
{
float score = confidence[j * num_class + i];
if (score > confidence_threshold)
{
const float* bbox = bboxes.row(j);
BBoxRect c = { bbox[0], bbox[1], bbox[2], bbox[3], i };
class_bbox_rects.push_back(c);
class_bbox_scores.push_back(score);
}
}
// sort inplace
qsort_descent_inplace(class_bbox_rects, class_bbox_scores);
// keep nms_top_k
if (nms_top_k < (int)class_bbox_rects.size())
{
class_bbox_rects.resize(nms_top_k);
class_bbox_scores.resize(nms_top_k);
}
// apply nms
std::vector<int> picked;
nms_sorted_bboxes(class_bbox_rects, picked, nms_threshold);
// select
for (int j = 0; j < (int)picked.size(); j++)
{
int z = picked[j];
all_class_bbox_rects[i].push_back(class_bbox_rects[z]);
all_class_bbox_scores[i].push_back(class_bbox_scores[z]);
}
}
// gather all class
std::vector<BBoxRect> bbox_rects;
std::vector<float> bbox_scores;
for (int i = 1; i < num_class; i++)
{
const std::vector<BBoxRect>& class_bbox_rects = all_class_bbox_rects[i];
const std::vector<float>& class_bbox_scores = all_class_bbox_scores[i];
bbox_rects.insert(bbox_rects.end(), class_bbox_rects.begin(), class_bbox_rects.end());
bbox_scores.insert(bbox_scores.end(), class_bbox_scores.begin(), class_bbox_scores.end());
}
// global sort inplace
qsort_descent_inplace(bbox_rects, bbox_scores);
// keep_top_k
if (keep_top_k < (int)bbox_rects.size())
{
bbox_rects.resize(keep_top_k);
bbox_scores.resize(keep_top_k);
}
// fill result
int num_detected = bbox_rects.size();
Mat& top_blob = top_blobs[0];
top_blob.create(6, num_detected);
if (top_blob.empty())
return -100;
for (int i = 0; i < num_detected; i++)
{
const BBoxRect& r = bbox_rects[i];
float score = bbox_scores[i];
float* outptr = top_blob.row(i);
outptr[0] = r.label;
outptr[1] = score;
outptr[2] = r.xmin;
outptr[3] = r.ymin;
outptr[4] = r.xmax;
outptr[5] = r.ymax;
}
return 0;
}
//
// Function that calculates Ackley's function, for 2 variables, for specified x & y values
//
double Ackley::ack2Vars(double x, double y){
double c1=20, c2=0.2, c3=2*PI;
return -c1*exp(-c2*sqrt(0.5*(x*x + y*y))) - exp(0.5*(cos(c3*x)+cos(c3*y))) + c1 + 1;
}
//The octave here refers to the 'internal' octave.
int get_freq(int octave, int note_ind)
{
double curr_ref_freq;
curr_ref_freq = REF_FREQ + (octave - REF_OCT) * log(2);
return (int)(exp(curr_ref_freq + note_ind * DLOG) * 1000 + 0.5);
}