BOOL DScm::ReadIsoMap(VOID)
{
DAssert(!m_IsoMap.isom && !m_IsoMap.tile);
if (!create_iso_map(&m_IsoMap, FALSE))
return FALSE;
UINT tile_size = m_Chk.GetSectionSize(FOURCC_TILE, DChk::ST_OVERRIDE);
if (tile_size) {
UINT full_size = m_IsoMap.size.cx * m_IsoMap.size.cy * sizeof(LTILEIDX);
UINT copy_size = DMin(tile_size, full_size);
if (!m_Chk.GetSectionData(FOURCC_TILE, DChk::ST_OVERRIDE, m_IsoMap.tile, copy_size))
return FALSE;
}
UINT isom_size = m_Chk.GetSectionSize(FOURCC_ISOM, DChk::ST_OVERRIDE);
if (isom_size) {
UINT full_size = CALC_ISOM_ROW(m_IsoMap.size.cx) * CALC_ISOM_LINE(m_IsoMap.size.cy) * sizeof(LISOMTILE);
UINT copy_size = DMin(isom_size, full_size);
if (!m_Chk.GetSectionData(FOURCC_ISOM, DChk::ST_OVERRIDE, m_IsoMap.isom, copy_size))
return FALSE;
}
UINT dd2_size = m_Chk.GetSectionSize(FOURCC_DD2, DChk::ST_DUPLICATE);
UINT dd_num = dd2_size / sizeof(DD2_DATA);
if (dd_num) {
DD2_DATA *dd2 = new DD2_DATA[dd_num];
if (!m_Chk.GetSectionData(FOURCC_DD2, DChk::ST_DUPLICATE, dd2, dd_num * sizeof(DD2_DATA)))
return FALSE;
// TODO:
delete [] dd2;
}
// TODO: recover TILE and ISOM
return TRUE;
}
BOOL DScm::ReadTile(VOID)
{
DAssert(!m_Tile);
UINT size = m_Chk.GetSectionSize(FOURCC_MTXM, DChk::ST_OVERRIDE);
if (size > DIM_HUGE * DIM_HUGE * sizeof(LTILEIDX))
return FALSE;
UINT map_size = m_IsoMap.size.cx * m_IsoMap.size.cy;
DAssert(map_size > 0);
m_Tile = new LTILEIDX[map_size];
map_size *= sizeof(LTILEIDX);
DMemClr(m_Tile, map_size);
UINT rd_size = DMin(map_size, size);
if (rd_size && !m_Chk.GetSectionData(FOURCC_MTXM, DChk::ST_OVERRIDE, m_Tile, rd_size))
return FALSE;
return TRUE;
}
int test_linearRand()
{
int Error = 0;
glm::int32 const Min = 16;
glm::int32 const Max = 32;
{
glm::u8vec2 AMin(std::numeric_limits<glm::u8>::max());
glm::u8vec2 AMax(std::numeric_limits<glm::u8>::min());
{
for(std::size_t i = 0; i < 100000; ++i)
{
glm::u8vec2 A = glm::linearRand(glm::u8vec2(Min), glm::u8vec2(Max));
AMin = glm::min(AMin, A);
AMax = glm::max(AMax, A);
if(!glm::all(glm::lessThanEqual(A, glm::u8vec2(Max))))
++Error;
if(!glm::all(glm::greaterThanEqual(A, glm::u8vec2(Min))))
++Error;
assert(!Error);
}
Error += glm::all(glm::equal(AMin, glm::u8vec2(Min))) ? 0 : 1;
Error += glm::all(glm::equal(AMax, glm::u8vec2(Max))) ? 0 : 1;
assert(!Error);
}
glm::u16vec2 BMin(std::numeric_limits<glm::u16>::max());
glm::u16vec2 BMax(std::numeric_limits<glm::u16>::min());
{
for(std::size_t i = 0; i < 100000; ++i)
{
glm::u16vec2 B = glm::linearRand(glm::u16vec2(Min), glm::u16vec2(Max));
BMin = glm::min(BMin, B);
BMax = glm::max(BMax, B);
if(!glm::all(glm::lessThanEqual(B, glm::u16vec2(Max))))
++Error;
if(!glm::all(glm::greaterThanEqual(B, glm::u16vec2(Min))))
++Error;
assert(!Error);
}
Error += glm::all(glm::equal(BMin, glm::u16vec2(Min))) ? 0 : 1;
Error += glm::all(glm::equal(BMax, glm::u16vec2(Max))) ? 0 : 1;
assert(!Error);
}
glm::u32vec2 CMin(std::numeric_limits<glm::u32>::max());
glm::u32vec2 CMax(std::numeric_limits<glm::u32>::min());
{
for(std::size_t i = 0; i < 100000; ++i)
{
glm::u32vec2 C = glm::linearRand(glm::u32vec2(Min), glm::u32vec2(Max));
CMin = glm::min(CMin, C);
CMax = glm::max(CMax, C);
if(!glm::all(glm::lessThanEqual(C, glm::u32vec2(Max))))
++Error;
if(!glm::all(glm::greaterThanEqual(C, glm::u32vec2(Min))))
++Error;
assert(!Error);
}
Error += glm::all(glm::equal(CMin, glm::u32vec2(Min))) ? 0 : 1;
Error += glm::all(glm::equal(CMax, glm::u32vec2(Max))) ? 0 : 1;
assert(!Error);
}
glm::u64vec2 DMin(std::numeric_limits<glm::u64>::max());
glm::u64vec2 DMax(std::numeric_limits<glm::u64>::min());
{
for(std::size_t i = 0; i < 100000; ++i)
{
glm::u64vec2 D = glm::linearRand(glm::u64vec2(Min), glm::u64vec2(Max));
DMin = glm::min(DMin, D);
DMax = glm::max(DMax, D);
if(!glm::all(glm::lessThanEqual(D, glm::u64vec2(Max))))
++Error;
if(!glm::all(glm::greaterThanEqual(D, glm::u64vec2(Min))))
++Error;
assert(!Error);
}
Error += glm::all(glm::equal(DMin, glm::u64vec2(Min))) ? 0 : 1;
Error += glm::all(glm::equal(DMax, glm::u64vec2(Max))) ? 0 : 1;
assert(!Error);
}
}
{
glm::i8vec2 AMin(std::numeric_limits<glm::i8>::max());
glm::i8vec2 AMax(std::numeric_limits<glm::i8>::min());
{
for(std::size_t i = 0; i < 100000; ++i)
{
glm::i8vec2 A = glm::linearRand(glm::i8vec2(Min), glm::i8vec2(Max));
AMin = glm::min(AMin, A);
AMax = glm::max(AMax, A);
if(!glm::all(glm::lessThanEqual(A, glm::i8vec2(Max))))
++Error;
if(!glm::all(glm::greaterThanEqual(A, glm::i8vec2(Min))))
++Error;
assert(!Error);
}
Error += glm::all(glm::equal(AMin, glm::i8vec2(Min))) ? 0 : 1;
Error += glm::all(glm::equal(AMax, glm::i8vec2(Max))) ? 0 : 1;
assert(!Error);
}
glm::i16vec2 BMin(std::numeric_limits<glm::i16>::max());
glm::i16vec2 BMax(std::numeric_limits<glm::i16>::min());
{
for(std::size_t i = 0; i < 100000; ++i)
{
glm::i16vec2 B = glm::linearRand(glm::i16vec2(Min), glm::i16vec2(Max));
BMin = glm::min(BMin, B);
BMax = glm::max(BMax, B);
if(!glm::all(glm::lessThanEqual(B, glm::i16vec2(Max))))
++Error;
if(!glm::all(glm::greaterThanEqual(B, glm::i16vec2(Min))))
++Error;
assert(!Error);
}
Error += glm::all(glm::equal(BMin, glm::i16vec2(Min))) ? 0 : 1;
Error += glm::all(glm::equal(BMax, glm::i16vec2(Max))) ? 0 : 1;
assert(!Error);
}
glm::i32vec2 CMin(std::numeric_limits<glm::i32>::max());
glm::i32vec2 CMax(std::numeric_limits<glm::i32>::min());
{
for(std::size_t i = 0; i < 100000; ++i)
{
glm::i32vec2 C = glm::linearRand(glm::i32vec2(Min), glm::i32vec2(Max));
CMin = glm::min(CMin, C);
CMax = glm::max(CMax, C);
if(!glm::all(glm::lessThanEqual(C, glm::i32vec2(Max))))
++Error;
if(!glm::all(glm::greaterThanEqual(C, glm::i32vec2(Min))))
++Error;
assert(!Error);
}
Error += glm::all(glm::equal(CMin, glm::i32vec2(Min))) ? 0 : 1;
Error += glm::all(glm::equal(CMax, glm::i32vec2(Max))) ? 0 : 1;
assert(!Error);
}
glm::i64vec2 DMin(std::numeric_limits<glm::i64>::max());
glm::i64vec2 DMax(std::numeric_limits<glm::i64>::min());
{
for(std::size_t i = 0; i < 100000; ++i)
{
glm::i64vec2 D = glm::linearRand(glm::i64vec2(Min), glm::i64vec2(Max));
DMin = glm::min(DMin, D);
DMax = glm::max(DMax, D);
if(!glm::all(glm::lessThanEqual(D, glm::i64vec2(Max))))
++Error;
if(!glm::all(glm::greaterThanEqual(D, glm::i64vec2(Min))))
++Error;
assert(!Error);
}
Error += glm::all(glm::equal(DMin, glm::i64vec2(Min))) ? 0 : 1;
Error += glm::all(glm::equal(DMax, glm::i64vec2(Max))) ? 0 : 1;
assert(!Error);
}
}
for(std::size_t i = 0; i < 100000; ++i)
{
glm::f32vec2 const A(glm::linearRand(glm::f32vec2(static_cast<float>(Min)), glm::f32vec2(static_cast<float>(Max))));
if(!glm::all(glm::lessThanEqual(A, glm::f32vec2(static_cast<float>(Max)))))
++Error;
if(!glm::all(glm::greaterThanEqual(A, glm::f32vec2(static_cast<float>(Min)))))
++Error;
glm::f64vec2 const B(glm::linearRand(glm::f64vec2(Min), glm::f64vec2(Max)));
if(!glm::all(glm::lessThanEqual(B, glm::f64vec2(Max))))
++Error;
if(!glm::all(glm::greaterThanEqual(B, glm::f64vec2(Min))))
++Error;
assert(!Error);
}
{
float ResultFloat = 0.0f;
double ResultDouble = 0.0f;
for(std::size_t i = 0; i < 100000; ++i)
{
ResultFloat += glm::linearRand(-1.0f, 1.0f);
ResultDouble += glm::linearRand(-1.0, 1.0);
}
Error += glm::epsilonEqual(ResultFloat, 0.0f, 0.0001f);
Error += glm::epsilonEqual(ResultDouble, 0.0, 0.0001);
assert(!Error);
}
return Error;
}
void DFO_TableCalibrationStatistics:: CalcOutput(FOcalcType calcType)
{
DoStatusChk();
if (!StatusOK())
return;
const SC_DoubleArray& xIn = *selectedColData;
const SC_DoubleArray& yIn = inputData->dataTable[selectedYCol];
double sumRes = 0.0;
double absRes = 0.0;
double sumSqr = 0.0;
double maxRes, minRes, maxY, minY;
int numRes = 0;
for (int i = 0; i < xIn.Size(); i++)
{
double nextX = xIn[i];
double nextY = yIn[i];
if (RealIsNull(nextX) || RealIsNull(nextY))
continue;
double currRes = nextX - nextY;
if (numRes == 0)
{
maxRes = currRes;
minRes = currRes;
maxY = nextY;
minY = nextY;
}
else
{
maxRes = DMax(maxRes, currRes);
minRes = DMin(minRes, currRes);
maxY = DMax(maxY, nextY);
minY = DMin(minY, nextY);
}
numRes++;
absRes += fabs(currRes);
sumRes += currRes;
sumSqr += Sqr(currRes);
}
if (numRes < 2)
{
SetObjErrMsg("Less than two points to calculate statistics for");
return;
}
maxOverPredictionDO.InitLabelAndValue(maxRes);
maxUnderPredictionDO.InitLabelAndValue(-minRes);
averageResidualDO.InitLabelAndValue(sumRes/double(numRes));
averageAbsResidualDO.InitLabelAndValue(absRes/double(numRes));
numMeasurementsDO.InitLabelAndValue(double(numRes));
normalizedResidualRMSDO.InitLabelAndValue(0.0);
if (sumSqr > 0.0)
{
double rms = sqrt(sumSqr/double(numRes));
residualRMSDO.InitLabelAndValue(rms);
double dy = maxY - minY;
if (dy > 0.0)
normalizedResidualRMSDO.InitLabelAndValue(rms / dy * 100.0);
}
else
{
residualRMSDO.InitLabelAndValue(0.0);
}
correlationCoefficientDO.InitLabelAndValue(PearsonR(xIn, yIn));
}
void PFO_CovarLimMatrix:: CalcOutput(FOcalcType calcType)
{
DoStatusChk();
if (StatusNotOK())
return;
//each covar matrix should always have same number of parameters
maxParam = (*covarArrayDC)[0].covarFitVals.Size();
if (plotWithColorMap && ColorAttributeIsDiag())
{
colorData.Alloc(maxCovar * maxParam * maxParam);
colorIndx = 0;
colorIndxMap.CubeAlloc(maxParam, maxParam, maxCovar);
}
percent = areaPct / 100.0;
minPercent = (1.0 - percent) / 2.0;
minDiag = 1E+10;
maxDiag = 0.0;
double aDiag, bDiag;
minVal = 0.0;
maxVal = 1.0;
double minSingle, maxSingle;
centerEllX.CubeAlloc(maxParam, maxParam, maxCovar);
centerEllY.CubeAlloc(maxParam, maxParam, maxCovar);
for (int i = 0; i < maxParam; i++)
{
centerEllX[i].MatrixFill(0.0);
centerEllY[i].MatrixFill(0.0);
}
double minShift = 0.0;
double maxShift = 0.0;
SC_PointArray ell;
for (int i = 0; i < maxParam; i++)
{
for (int j = i; j < maxParam; j++)
{
for (int k = 0; k < covarArrayDC->Size(); k++)
{
if (plotWithColorMap && ColorAttributeIsDiag())
colorIndxMap[i][j][k] = 0;
if ((i == j) && Get2DSingle(i, k, minSingle, maxSingle))
{
//find total min and max for complete data set
minVal = DMin(minSingle, minVal);
maxVal = DMax(maxSingle, maxVal);
aDiag = (maxSingle - minSingle) / 2.0;
bDiag = aDiag;
MinMaxDiag(aDiag, bDiag, i, j, k);
}
if ((i != j) && Get2DDual(i, j, k, ell, aDiag, bDiag))
{
MinMaxDiag(aDiag, bDiag, i, j, k);
//find min max ellipse points
// to calc center pt for shift
// and if any outside 0-1, renormalize
double minX = 1E+10;
double maxX = -1E+10;
double minY = 1E+10;
double maxY = -1E+10;
for (int ii = 0; ii < ell.Size(); ii++)
{
if (ell[ii].pX < minX)
minX = ell[ii].pX;
if (ell[ii].pY < minY)
minY = ell[ii].pY;
if (ell[ii].pX > maxX)
maxX = ell[ii].pX;
if (ell[ii].pY > maxY)
maxY = ell[ii].pY;
}
if (centerEllipse)
{
centerEllX[i][j][k] = minX + ((maxX - minX) / 2.0);
centerEllY[i][j][k] = minY + ((maxY - minY) / 2.0);
minShift = DMin(minShift,
(0.5 - centerEllX[i][j][k]),
(0.5 - centerEllY[i][j][k]));
maxShift = DMax(maxShift,
(0.5 - centerEllX[i][j][k]),
(0.5 - centerEllY[i][j][k]));
}
//find total min and max for complete data set
minVal = DMin(minX, minY, minVal);
maxVal = DMax(maxX, maxY, maxVal);
}//if get dual
}//k covar
}//j param
}//i param
if (centerEllipse)
{
minVal += minShift;
maxVal += maxShift;
}
if (plotWithColorMap)
{
if (ColorAttributeIsDiag())
{
colorData.SetSize(colorIndx);
if (limitIsMaster && autoLimits)
rangeLimit.InitLimit(colorData);
CheckRangeLimits();
}
}
}
