// Choose applicable inaccuracy functions for current game mode and target type
void Player::Inaccuracy(){
int i = 0;
if (p_colinmode) {
switch (p_targettype) {
case 0: ColinSingle(); break;
case 1: ColinSingle(); break;
case 2: ColinDouble(); break;
case 3: ColinTreble(); break;
case 4: ColinBull(); break;
}
if (p_targettype == 2 || p_targettype == 3) {
for (i = 0; boardpoints[i] != p_hit/p_targettype; i++){
}
p_targetindex = i;
} else if (p_targettype == 0) {
for (i = 0; boardpoints[i] != p_hit; i++) {
}
p_targetindex = i;
}
} else {
switch (p_targettype) {
case 0: Single(); break;
case 1: Bull(); break;
case 2: Double(); break;
case 3: Treble(); break;
case 4: BullsEye(); break;
}
}
}
/**
* @brief ProcessAux
* @param imgIn
* @param bBilateral
* @param nSuperPixels
* @return
*/
Image *ProcessAux(Image *imgIn, bool bBilateral, int nSuperPixels = 4096)
{
if(bBilateral) {
float minVal, maxVal;
imgIn->getMinVal(NULL, &minVal);
imgIn->getMaxVal(NULL, &maxVal);
float nLevels = log10f(maxVal) - log10f(minVal) + 1.0f;
float nLayer = ((maxVal - minVal) / nLevels) / 4.0f;
float area = imgIn->widthf * imgIn->heightf * perCent;
int iterations = MAX(int(sqrtf(area)) / 2, 1);
//create filters
if(fltIt == NULL) {
fltBil = new FilterBilateral2DS(1.0f, nLayer);
fltIt = new FilterIterative(fltBil, iterations);
}
#ifdef PIC_DEBUG
printf("Layer: %f iterations: %d\n", nLayer, iterations);
#endif
//Iterative bilateral filtering
Image *imgOut = fltIt->Process(Single(imgIn), imgIn_flt);
return imgOut;
} else {
Slic sp;
sp.execute(imgIn, nSuperPixels);
Image *imgOut = sp.getMeanImage(NULL);
return imgOut;
}
}
static Image *execute(Image *imgIn, Image *imgOut,
float sigma1, float sigma2,
int direction)
{
FilterDiffGauss1D filter(sigma1, sigma2, direction);
return filter.Process(Single(imgIn), imgOut);
}
/**
* @brief Execute_XYZ_to_RGB
* @param imgIn
* @param imgOut
* @return
*/
static Image *Execute_XYZ_to_RGB(Image *imgIn, Image *imgOut)
{
FilterLinearColorSpace flt;
flt.getXYZ2RGBMatrix();
return flt.ProcessP(Single(imgIn), imgOut);
}
/**
* @brief execute
* @param imgIn
* @param imgOut
* @param sigma_s
* @param sigma_r
* @return
*/
static Image *execute(Image *imgIn, Image *imgOut,
float sigma_s, float sigma_r)
{
//filter
FilterBilateral2DF filter(sigma_s, sigma_r);
Image *out = filter.Process(Single(imgIn), imgOut);
return out;
}
/**
* @brief fromRGBtoXYZ
* @param imgIn
* @param imgOut
* @return
*/
static Image *fromRGBtoXYZ(Image *imgIn, Image *imgOut)
{
ColorConvRGBtoXYZ cc_from_RGB_to_XYZ;
FilterColorConv flt;
flt.insertColorConv(&cc_from_RGB_to_XYZ, true);
return flt.Process(Single(imgIn), imgOut);
}
/**
* @brief Test
*/
static void Test()
{
Image imgIn(1, 512, 512, 3);
imgIn = 1.0f;
FilterChannel filter(0);
Image *outR = filter.Process(Single(&imgIn), NULL);
filter.setChannel(1);
Image *outG = filter.Process(Single(&imgIn), NULL);
filter.setChannel(2);
Image *outB = filter.Process(Single(&imgIn), NULL);
outR->Write("channel_R.pfm");
outG->Write("channel_G.pfm");
outB->Write("channel_B.pfm");
}
/**
* @brief test
*/
static void test()
{
Image img(1, 512, 512, 3);
img = 1.0f;
FilterCrop flt(Vec2i(100, 100), Vec2i(200, 200));
Image *out = flt.Process(Single(&img), NULL);
out->Write("test_crop_2d_output.pfm");
}
/**
* @brief fromCIELABtoRGB
* @param imgIn
* @param imgOut
* @return
*/
static Image *fromCIELABtoRGB(Image *imgIn, Image *imgOut)
{
ColorConvRGBtoXYZ cc_from_RGB_to_XYZ;
ColorConvXYZtoCIELAB cc_from_XYZ_to_CIELAB;
FilterColorConv flt;
flt.insertColorConv(&cc_from_XYZ_to_CIELAB, false);
flt.insertColorConv(&cc_from_RGB_to_XYZ, false);
return flt.Process(Single(imgIn), imgOut);
}
bool Single::buildFromString(std::string value, std::vector<Single>& list)
{
uint32_t iValue = inet_addr(value.c_str());
if (iValue) {
list.push_back(Single(iValue));
return true;
}
return false;
}
void Bitboard::Print(U64 b)
{
out("\n");
for (int f = 0; f < 64; f++)
{
if (b & Single(f))
out(" 1");
else
out(" -");
if (Col(f) == 7) out("\n");
}
out("\n");
}
/**
* @brief ExectueCIELABtoRGB
* @param imgIn
* @param imgOut
* @param bDirect
* @return
*/
static Image *CIELABtoRGB(Image *imgIn, Image *imgOut,
bool bDirect)
{
ColorConvRGBtoXYZ csXYZ;
ColorConvXYZtoCIELAB csCIELAB;
FilterColorConv flt(NULL, bDirect);
flt.insertColorConv(&csCIELAB);
flt.insertColorConv(&csXYZ);
return flt.Process(Single(imgIn), imgOut);
}
/**
* @brief RGBtoLogLuv
* @param imgIn
* @param imgOut
* @param bDirect
* @return
*/
static Image *RGBtoLogLuv(Image *imgIn, Image *imgOut,
bool bDirect)
{
ColorConvRGBtoXYZ csXYZ;
ColorConvXYZtoLogLuv csLogLuv;
FilterColorConv flt(NULL, bDirect);
flt.insertColorConv(&csXYZ);
flt.insertColorConv(&csLogLuv);
return flt.Process(Single(imgIn), imgOut);
}
/**
* @brief ExecuteTest
* @param nameIn
* @param nameOut
* @return
*/
static Image *ExecuteTest(std::string nameIn, std::string nameOut)
{
Image imgIn(nameIn);
FilterChannel filter(0);
Image *outR = filter.Process(Single(&imgIn), NULL);
filter.setChannel(1);
Image *outG = filter.Process(Single(&imgIn), NULL);
filter.setChannel(2);
Image *outB = filter.Process(Single(&imgIn), NULL);
ImageVec src;
src.push_back(outR);
src.push_back(outG);
src.push_back(outB);
FilterCombine filterC;
Image *ret = filterC.Process(src, NULL);
ret->Write(nameOut);
return ret;
}
/*
**** This test is designed to test the validity of the Evaluate member of the PolyFit class
**** This particular test only involves using Evaluate for a single datum and a blank, singular
**** and a normal PolyFit.
**** The Evaluate is tested by using the solution to a + b*x = d
*/
void xPolyFit :: evalTestSingle (void)
{
gpstk::PolyFit<double> Blank;
gpstk::PolyFit<double> Single(2);
gpstk::PolyFit<double> Eval(2);
double data[4] = {0.,2.,4.,-1.};
double time[4] = {3.,3.,4.,2.,};
double dataS[4] = {1.,1.,1.,1.};
double timeS[4] = {0.,0.,0.,1.,};
for (int i =0;i<4;i++)
{
Eval.Add(time[i],data[i]);
Single.Add(timeS[i],dataS[i]);
}
gpstk::Vector<double> EvalSolution = Eval.Solution();
CPPUNIT_ASSERT_EQUAL(0.,Blank.Evaluate(3.));
CPPUNIT_ASSERT_EQUAL(0.,Single.Evaluate(10.));
CPPUNIT_ASSERT_DOUBLES_EQUAL(EvalSolution[0]+3.*EvalSolution[1], Eval.Evaluate(3.),1e-6);
}
int main ()
{
int num = 10;
int temp = 0;
header = (struct List*)malloc(sizeof(struct List));
now = header;
for(temp = 0;temp<num-1&&num>=1;temp++)
{
now->next = (struct List*)malloc(sizeof(struct List));
now = now->next;
if(temp == num-2)
{
now->next = NULL;
}
}
printf("The number of the node in single list is :%d\n",Single(header));
return 0;
}
/*
**** This test is designed to test the validity of the Evaluate member of the PolyFit class
**** This particular test only involves using Evaluate for a gpstk::Vectors of data with
**** a blank, singular, and a normal PolyFit.
**** The Evaluate is tested by using the solution to a + b*x = d
*/
void xPolyFit :: evalTestVector (void)
{
gpstk::PolyFit<double> Blank;
gpstk::PolyFit<double> Single(2);
gpstk::PolyFit<double> Eval(2);
gpstk::Vector<double> SData(4,0.);
SData[0] = 1.;
SData[1] = 1.;
SData[2] = 1.;
SData[3] = 1.;
gpstk::Vector<double> STime(4,0.);
STime[0] = 0.;
STime[1] = 0.;
STime[2] = 0.;
STime[3] = 1.;
gpstk::Vector<double> EData(4,0.);
EData[0] = 0.;
EData[1] = 2.;
EData[2] = 4.;
EData[3] = -1.;
gpstk::Vector<double> ETime(4,0.);
ETime[0] = 3.;
ETime[1] = 3.;
ETime[2] = 4.;
ETime[3] = 2.;
Single.Add(STime,SData);
Eval.Add(ETime,EData);
gpstk::Vector<double> EvalSolution = Eval.Solution();
CPPUNIT_ASSERT_EQUAL(0.,Blank.Evaluate(3.));
CPPUNIT_ASSERT_EQUAL(0.,Single.Evaluate(10.));
CPPUNIT_ASSERT_DOUBLES_EQUAL(EvalSolution[0]+3.*EvalSolution[1], Eval.Evaluate(3.),1e-6);
}
/**
* @brief execute
* @param imgIn
* @param imgOut
* @return
*/
static Image *execute(Image *imgIn, Image *imgOut)
{
FilterBackwardDifference filter;
return filter.Process(Single(imgIn), imgOut);
}
static Image *Execute(Image *imgIn, Image *imgOut, float sigma,
int direction)
{
FilterGaussian1D filter(sigma, direction);
return filter.ProcessP(Single(imgIn), imgOut);
}
/**
* @brief Execute
* @param in
* @param isb
* @param scale
* @return
*/
static Image *Execute(Image *in, ImageSampler *isb, float scale)
{
FilterSampler3D filterUp(scale, isb);
Image *out = filterUp.Process(Single(in), NULL);
return out;
}
/**
* @brief execute
* @param imgIn
* @param imgOut
* @param color
* @param sigma
* @return
*/
static Image *execute(Image *imgIn, Image *imgOut, float *color,
float sigma)
{
FilterColorDistance fltColDst(color, sigma);
return fltColDst.Process(Single(imgIn), imgOut);
}
/**
* @brief Transform
* @param imgIn
* @param imgOut
* @param nCoeff
* @return
*/
static Image *Transform(Image *imgIn, Image *imgOut, int nCoeff)
{
FilterDCT2D filter(nCoeff, true);
return filter.Process(Single(imgIn), imgOut);
}
/**
* @brief Inverse
* @param imgIn
* @param imgOut
* @param nCoeff
* @return
*/
static Image *Inverse(Image *imgIn, Image *imgOut, int nCoeff)
{
FilterDCT2D filter(nCoeff, false);
return filter.ProcessP(Single(imgIn), imgOut);
}
const char* Quote::Single (const char* str)
{
csStringBase& outStr (GetReturnString());
Single (outStr, str);
return outStr;
}
/**
* @brief Execute
* @param imgIn
* @param imgOut
* @param min
* @param max
* @return
*/
static Image *Execute(Image *imgIn, Image *imgOut, Vec4i min,
Vec4i max)
{
FilterCrop fltCrop(min, max);
return fltCrop.Process(Single(imgIn), imgOut);
}
/**
* @brief execute
* @param imgIn
* @param imgOut
* @return
*/
static Image *execute(Image *imgIn, Image *imgOut)
{
DurandTMO dtmo(5.0f);
return dtmo.Process(Single(imgIn), imgOut);
}
/**
* @brief Execute
* @param imgIn
* @param imgOut
* @param size
* @return
*/
static Image *Execute(Image *imgIn, Image *imgOut, int size)
{
FilterMax filter(size);
return filter.ProcessP(Single(imgIn), imgOut);
}
/**
* @brief Execute
* @param imgIn
* @param imgOut
* @param channel
* @return
*/
static Image *Execute(Image *imgIn, Image *imgOut, int channel = 0)
{
FilterChannel fltCh(channel);
return fltCh.ProcessP(Single(imgIn), imgOut);
}
/**
* @brief execute
* @param imgIn
* @param imgOut
* @param isb
* @return
*/
static Image *execute(Image *imgIn, Image *imgOut, ImageSampler *isb)
{
FilterSampler2DSub filter(isb);
return filter.Process(Single(imgIn), imgOut);
}
/**
* @brief execute
* @param imgIn
* @param imgOut
* @return
*/
Image *execute(Image *imgIn, Image *imgOut)
{
if(imgIn == NULL) {
return NULL;
}
if(!imgIn->isValid()) {
return NULL;
}
if(imgOut == NULL) {
imgOut = new Image(1, imgIn->width, imgIn->height, imgIn->channels);
}
//compute segmentation map
seg_map = seg.Process(imgIn, seg_map);
/* 0 ---> Drago et al. 2003
1 ---> Reinhard et al. 2002
LumZone = [-2, -1, 0, 1, 2, 3, 4];
TMOForZone = [ 0, 0, 1, 0, 1, 0, 0]; */
int count[2];
count[0] = 0;
count[1] = 0;
for(int i = 0; i < seg_map->size(); i++) {
int indx = int(seg_map->data[i]);
if((indx == 2) || (indx == 4)) {
seg_map->data[i] = 1.0f;
count[1]++;
} else {
seg_map->data[i] = 0.0f;
count[0]++;
}
}
#ifdef PIC_DEBUG
seg_map->Write("weight_map.pfm");
#endif
//check if we have different zones
int value = 10;
if(count[0] > 0 && count[1] > 0) {
value = 10;
}
if(count[0] > 0 && count[1] == 0) {
value = 0;
}
if(count[0] == 0 && count[1] > 0) {
value = 1;
}
switch(value) {
case 0: {
fltDragoTMO.Process(Single(imgIn), imgOut);
}
break;
case 1: {
fltReinhardTMO.Process(Single(imgIn), imgOut);
}
break;
case 10: {
//Drago TMO
imgDrago = fltDragoTMO.Process(Single(imgIn), imgDrago);
if(pyrA == NULL) {
pyrA = new Pyramid(imgDrago, true);
} else {
pyrA->update(imgDrago);
}
//Reinhard TMO
imgReinhard = fltReinhardTMO.Process(Single(imgIn), imgReinhard);
if(pyrB == NULL) {
pyrB = new Pyramid(imgReinhard, true);
} else {
pyrB->update(imgReinhard);
}
//compute blending weight
if(pyrWeight == NULL) {
pyrWeight = new Pyramid(seg_map, false);
} else {
pyrWeight->update(seg_map);
}
//blend
pyrA->blend(pyrB, pyrWeight);
pyrA->reconstruct(imgOut);
}
break;
}
return imgOut;
}
