dgInt32 dgCollisionSphere::CalculateSignature (dgFloat32 radius)
{
dgUnsigned32 buffer[2];
radius = dgAbsf (radius);
buffer[0] = m_sphereCollision;
buffer[1] = Quantize (radius);
return Quantize(buffer, sizeof (buffer));
}
dgInt32 dgCollisionCylinder::CalculateSignature (dgFloat32 radio0, dgFloat32 radio1, dgFloat32 height)
{
dgUnsigned32 buffer[4];
buffer[0] = m_cylinderCollision;
buffer[1] = Quantize (radio0);
buffer[2] = Quantize (radio1);
buffer[3] = Quantize (height);
return Quantize(buffer, sizeof (buffer));
}
dgInt32 dgCollisionTaperedCapsule::CalculateSignature (dgFloat32 radio0, dgFloat32 radio1, dgFloat32 height)
{
dgUnsigned32 buffer[4];
buffer[0] = m_taperedCapsuleCollision;
buffer[1] = Quantize (radio0);
buffer[2] = Quantize (radio1);
buffer[3] = Quantize (height);
return Quantize(buffer, sizeof (buffer));
}
void
avtOpacityMap::AddRange(double lo, double hi, RGBA &rgba)
{
int low = Quantize(lo);
int high = Quantize(hi);
for (int i = low ; i <= high ; i++)
{
table[i].R = rgba.R;
table[i].G = rgba.G;
table[i].B = rgba.G;
table[i].A = rgba.A;
}
}
dgInt32 dgCollisionBox::CalculateSignature (dgFloat32 dx, dgFloat32 dy, dgFloat32 dz)
{
dgUnsigned32 buffer[4];
dx = dgAbsf (dx);
dy = dgAbsf (dy);
dz = dgAbsf (dz);
buffer[0] = m_boxCollision;
buffer[1] = Quantize (dx * dgFloat32 (0.5f));
buffer[2] = Quantize (dy * dgFloat32 (0.5f));
buffer[3] = Quantize (dz * dgFloat32 (0.5f));
return Quantize(buffer, sizeof (buffer));
}
unsigned short AxisSweep3::AddHandle(const SimdPoint3& aabbMin,const SimdPoint3& aabbMax, void* pOwner,short int collisionFilterGroup,short int collisionFilterMask)
{
// quantize the bounds
unsigned short min[3], max[3];
Quantize(min, aabbMin, 0);
Quantize(max, aabbMax, 1);
// allocate a handle
unsigned short handle = AllocHandle();
assert(handle!= 0xcdcd);
Handle* pHandle = GetHandle(handle);
pHandle->m_handleId = handle;
//pHandle->m_pOverlaps = 0;
pHandle->m_clientObject = pOwner;
pHandle->m_collisionFilterGroup = collisionFilterGroup;
pHandle->m_collisionFilterMask = collisionFilterMask;
// compute current limit of edge arrays
int limit = m_numHandles * 2;
// insert new edges just inside the max boundary edge
for (int axis = 0; axis < 3; axis++)
{
m_pHandles[0].m_maxEdges[axis] += 2;
m_pEdges[axis][limit + 1] = m_pEdges[axis][limit - 1];
m_pEdges[axis][limit - 1].m_pos = min[axis];
m_pEdges[axis][limit - 1].m_handle = handle;
m_pEdges[axis][limit].m_pos = max[axis];
m_pEdges[axis][limit].m_handle = handle;
pHandle->m_minEdges[axis] = limit - 1;
pHandle->m_maxEdges[axis] = limit;
}
// now sort the new edges to their correct position
SortMinDown(0, pHandle->m_minEdges[0], false);
SortMaxDown(0, pHandle->m_maxEdges[0], false);
SortMinDown(1, pHandle->m_minEdges[1], false);
SortMaxDown(1, pHandle->m_maxEdges[1], false);
SortMinDown(2, pHandle->m_minEdges[2], true);
SortMaxDown(2, pHandle->m_maxEdges[2], true);
//PrintAxis(1);
return handle;
}
void
FullStateSenderPlayerV5::sendPlayer( const Player & p )
{
const float quantize_step = .001;
char side = ( p.side() == LEFT ? 'l' : 'r' );
serializer().serializeFSPlayerBegin( transport(),
side,
p.unum(),
false, // goalie info not sent
0, // player type info not sent
Quantize( p.pos().x,
quantize_step ), //pos_x
Quantize( p.pos().y,
quantize_step ), //pos_y
Quantize( p.vel().x,
quantize_step ), //vel_x
Quantize( p.vel().y,
quantize_step ), //vel_y
Quantize( Rad2Deg( p.angleBodyCommitted() ),
quantize_step ),
Quantize( Rad2Deg( p.angleNeckCommitted() ),
quantize_step ) ); //neck_angle
serializer().serializeFSPlayerStamina( transport(),
int( p.stamina() ),
Quantize( p.effort(), .0001 ),
Quantize( p.recovery(), .0001 ),
p.staminaCapacity() );
serializer().serializeFSPlayerEnd( transport() );
}
void
FullStateSenderPlayerV5::sendBall()
{
const float quantize_step = .001;
serializer().serializeFSBall( transport(),
Quantize( stadium().ball().pos().x,
quantize_step ),
Quantize( stadium().ball().pos().y,
quantize_step ),
Quantize( stadium().ball().vel().x,
quantize_step ),
Quantize( stadium().ball().vel().y,
quantize_step ) );
}
vector<intn> Quantize(
const vector<floatn>& points, const Resln& resln,
const BoundingBox<floatn>* customBB, const bool clamped) {
if (points.empty())
return vector<intn>();
BoundingBox<floatn> bb;
if (customBB) {
bb = *customBB;
} else {
for (const floatn& p : points) {
bb(p);
}
}
const float dwidth = bb.max_size();
if (dwidth == 0) {
vector<intn> ret;
ret.push_back({0,0});
return ret;
}
// Quantize points to integers
vector<intn> qpoints(points.size());
for (int i = 0; i < points.size(); ++i) {
const floatn& p = points[i];
const intn q = Quantize(p, resln, bb, dwidth, clamped);
qpoints[i] = q;
}
return qpoints;
}
bool FGSensor::Run(void )
{
Input = InputNodes[0]->getDoubleValue() * InputSigns[0];
Output = Input; // perfect sensor
// Degrade signal as specified
if (fail_stuck) {
Output = PreviousOutput;
return true;
}
if (lag != 0.0) Lag(); // models sensor lag and filter
if (noise_variance != 0.0) Noise(); // models noise
if (drift_rate != 0.0) Drift(); // models drift over time
if (bias != 0.0) Bias(); // models a finite bias
if (delay != 0.0) Delay(); // models system signal transport latencies
if (fail_low) Output = -HUGE_VAL;
if (fail_high) Output = HUGE_VAL;
if (bits != 0) Quantize(); // models quantization degradation
Clip(); // Is it right to clip a sensor?
return true;
}
void StreamDisplay::DrawPrimitives()
{
DrawMask( m_fTrailingPercent ); // this is the "right endcap" to the life
const float fChamberWidthInPercent = 1.0f/m_iNumChambers;
float fStripWidthInPercent = 1.0f/m_iNumStrips;
float fPercentBetweenStrips = 1.0f/m_iNumStrips;
// round down so that the chamber overflows align
if( m_iNumChambers > 10 )
fPercentBetweenStrips = Quantize( fPercentBetweenStrips-fChamberWidthInPercent/2, fChamberWidthInPercent );
if( m_iNumChambers > 3 )
fPercentBetweenStrips -= 2*fChamberWidthInPercent;
float fPercentOffset = fmodf( GAMESTATE->m_fSongBeat/4+1000, fPercentBetweenStrips );
ASSERT( fPercentOffset >= 0 && fPercentOffset <= fPercentBetweenStrips );
// "+fPercentBetweenStrips" so that the whole area is overdrawn 2x
for( float f=fPercentOffset+1+fPercentBetweenStrips; f>=0; f-=fPercentBetweenStrips )
{
DrawMask( f );
DrawStrip( f, fStripWidthInPercent );
}
// Don't leave the Zbuffer in a messy state for arrows and dancing characters
DISPLAY->ClearZBuffer();
}
Mat RegionSaliency::GetRCNoColorConversion(const Mat &img3f, double sigmaDist, double segK, int segMinSize, double segSigma)
{
Mat regIdx1i, colorIdx1i, regSal1v, tmp, _img3f, color3fv;
if (Quantize(img3f, colorIdx1i, color3fv, tmp) <= 2) // Color quantization
return Mat::zeros(img3f.size(), CV_32F);
_img3f = img3f.clone();
// cvtColor(img3f, _img3f, CV_BGR2Lab);
// cvtColor(color3fv, color3fv, CV_BGR2Lab);
int regNum = SegmentImage(_img3f, regIdx1i, segSigma, segK, segMinSize);
vector<Region> regs(regNum);
BuildRegions(regIdx1i, regs, colorIdx1i, color3fv.cols);
RegionContrast(regs, color3fv, regSal1v, sigmaDist);
Mat sal1f = Mat::zeros(img3f.size(), CV_32F);
cv::normalize(regSal1v, regSal1v, 0, 1, NORM_MINMAX, CV_32F);
float* regSal = (float*)regSal1v.data;
for (int r = 0; r < img3f.rows; r++){
const int* regIdx = regIdx1i.ptr<int>(r);
float* sal = sal1f.ptr<float>(r);
for (int c = 0; c < img3f.cols; c++)
sal[c] = regSal[regIdx[c]];
}
GaussianBlur(sal1f, sal1f, Size(3, 3), 0);
return sal1f;
}
void FGSensor::ProcessSensorSignal(void)
{
Output = Input; // perfect sensor
// Degrade signal as specified
if (fail_stuck) {
Output = PreviousOutput;
} else {
if (lag != 0.0) Lag(); // models sensor lag and filter
if (noise_variance != 0.0) Noise(); // models noise
if (drift_rate != 0.0) Drift(); // models drift over time
if (gain != 0.0) Gain(); // models a finite gain
if (bias != 0.0) Bias(); // models a finite bias
if (delay != 0) Delay(); // models system signal transport latencies
if (fail_low) Output = -HUGE_VAL;
if (fail_high) Output = HUGE_VAL;
if (bits != 0) Quantize(); // models quantization degradation
Clip();
}
}
void NoteDisplay::SetActiveFrame( float fNoteBeat, Actor &actorToSet, float fAnimationLengthInBeats, bool bVivid, bool bNoteColor )
{
/* -inf ... inf */
float fSongBeat = GAMESTATE->m_fSongBeat;
/* -len ... +len */
float fPercentIntoAnimation = fmodf( fSongBeat, fAnimationLengthInBeats );
/* -1 ... 1 */
fPercentIntoAnimation /= fAnimationLengthInBeats;
if( bVivid )
{
// changed to deal with the minor complaint that the color cycling is
// one tick off in general
const float fNoteBeatFraction = fmodf( fNoteBeat, 1.0f );
const float fFraction = fNoteBeatFraction - 0.25f/fAnimationLengthInBeats;
const float fInterval = 1.f / fAnimationLengthInBeats;
fPercentIntoAnimation += Quantize(fFraction,fInterval);
// just in case somehow we're majorly negative with the subtraction
wrap( fPercentIntoAnimation, 1.f );
}
else
{
/* 0 ... 1, wrapped */
if( fPercentIntoAnimation < 0 )
fPercentIntoAnimation += 1.0f;
}
float fLengthSeconds = actorToSet.GetAnimationLengthSeconds();
actorToSet.SetSecondsIntoAnimation( fPercentIntoAnimation*fLengthSeconds );
}
void FGSensor::ProcessSensorSignal(void)
{
Output = Input; // perfect sensor
// Degrade signal as specified
if (fail_stuck) {
Output = PreviousOutput;
} else if (fcs->GetTrimStatus()) {
if (lag != 0.0) {PreviousOutput = Output; PreviousInput = Input;}
if (drift_rate != 0.0) drift = 0;
if (gain != 0.0) Gain(); // models a finite gain
if (bias != 0.0) Bias(); // models a finite bias
if (delay != 0) for (int i=0; i<delay; i++) output_array[i] = Output;
Clip();
} else {
if (lag != 0.0) Lag(); // models sensor lag and filter
if (noise_variance != 0.0) Noise(); // models noise
if (drift_rate != 0.0) Drift(); // models drift over time
if (gain != 0.0) Gain(); // models a finite gain
if (bias != 0.0) Bias(); // models a finite bias
if (delay != 0) Delay(); // models system signal transport latencies
if (fail_low) Output = -HUGE_VAL;
if (fail_high) Output = HUGE_VAL;
if (bits != 0) Quantize(); // models quantization degradation
Clip();
}
if (IsOutput) SetOutput();
}
Mat RegionSaliency::GetRCCB(const Mat &img3f, double sigmaDist, double segK, int segMinSize, double segSigma,
double centerBiasWeight, double centerBiasHeightSigma, double centerBiasWidthSigma, const CenterBiasCombinationType_t cbct)
{
Mat regIdx1i, colorIdx1i, regSal1v, tmp, _img3f, color3fv;
if (Quantize(img3f, colorIdx1i, color3fv, tmp) <= 2) // Color quantization
return Mat::zeros(img3f.size(), CV_32F);
cvtColor(img3f, _img3f, CV_BGR2Lab);
cvtColor(color3fv, color3fv, CV_BGR2Lab);
int regNum = SegmentImage(_img3f, regIdx1i, segSigma, segK, segMinSize);
vector<Region> regs(regNum);
BuildRegions(regIdx1i, regs, colorIdx1i, color3fv.cols);
RegionContrast(regs, color3fv, regSal1v, sigmaDist);
float* regsCenterBias = new float[regNum]; // the center-bias for each region
float w0 = (float)centerBiasWidthSigma; // std. dev. of the Gaussian (width)
float h0 = (float)centerBiasHeightSigma; // std. dev. of the Gaussian (height)
for (int i = 0; i < regNum; i++)
{
const float x0 = 0.5;
const float y0 = 0.5;
regsCenterBias[i] = ( exp((-SQR(regs[i].centroid.x-x0))/SQR(w0)) * exp((-SQR(regs[i].centroid.y-y0))/SQR(h0)) );
}
Mat sal1f = Mat::zeros(img3f.size(), CV_32F);
cv::normalize(regSal1v, regSal1v, 0, 1, NORM_MINMAX, CV_32F);
float* regSal = (float*)regSal1v.data;
for (int r = 0; r < img3f.rows; r++)
{
const int* regIdx = regIdx1i.ptr<int>(r);
float* sal = sal1f.ptr<float>(r);
for (int c = 0; c < img3f.cols; c++)
{
switch (cbct)
{
case CB_LINEAR:
sal[c] = (1-centerBiasWeight)*regSal[regIdx[c]] + centerBiasWeight*regsCenterBias[regIdx[c]];
break;
case CB_PRODUCT:
sal[c] = regSal[regIdx[c]] * regsCenterBias[regIdx[c]]; // weighting in this case would have no influence
break;
case CB_MAX:
sal[c] = std::max((1-centerBiasWeight)*regSal[regIdx[c]], centerBiasWeight*regsCenterBias[regIdx[c]]);
break;
case CB_MIN:
sal[c] = std::min((1-centerBiasWeight)*regSal[regIdx[c]], centerBiasWeight*regsCenterBias[regIdx[c]]);
break;
default:
assert(false);
exit(-1);
}
}
}
GaussianBlur(sal1f, sal1f, Size(3, 3), 0);
delete [] regsCenterBias;
return sal1f;
}
void Quantizer::Quantize(const Gesture& gesture, TimeSlot& symbolSeq) const{
symbolSeq.gestureName = gesture.gestureName;
symbolSeq.quantizerName = name;
symbolSeq.M = M;
symbolSeq.o.clear();
for(vector<Acceleration>::const_iterator i = gesture.data.begin(); i<gesture.data.end(); i++)
symbolSeq.o.push_back(Quantize(*i));
}
void AdjustSync::GetSyncChangeTextGlobal( vector<RString> &vsAddTo )
{
{
float fOld = Quantize( AdjustSync::s_fGlobalOffsetSecondsOriginal, 0.001f );
float fNew = Quantize( PREFSMAN->m_fGlobalOffsetSeconds, 0.001f ) ;
float fDelta = fNew - fOld;
if( fabsf(fDelta) > 0.0001f )
{
vsAddTo.push_back( ssprintf(
GLOBAL_OFFSET_FROM.GetValue(),
fOld,
fNew,
(fDelta > 0 ? EARLIER:LATER).GetValue().c_str() ) );
}
}
}
void CmSaliencyRC::SmoothByHist(CMat &img3f, Mat &sal1f, float delta)
{
//imshow("Before", sal1f); imshow("Src", img3f);
// Quantize colors
CV_Assert(img3f.size() == sal1f.size() && img3f.type() == CV_32FC3 && sal1f.type() == CV_32FC1);
Mat idx1i, binColor3f, colorNums1i;
int binN = Quantize(img3f, idx1i, binColor3f, colorNums1i);
//CmShow::HistBins(binColor3f, colorNums1i, "Frequency");
// Get initial color saliency
Mat _colorSal = Mat::zeros(1, binN, CV_64FC1);
int rows = img3f.rows, cols = img3f.cols;{
double* colorSal = (double*)_colorSal.data;
if (img3f.isContinuous() && sal1f.isContinuous())
cols *= img3f.rows, rows = 1;
for (int y = 0; y < rows; y++){
const int* idx = idx1i.ptr<int>(y);
const float* initialS = sal1f.ptr<float>(y);
for (int x = 0; x < cols; x++)
colorSal[idx[x]] += initialS[x];
}
const int *colorNum = (int*)(colorNums1i.data);
for (int i = 0; i < binN; i++)
colorSal[i] /= colorNum[i];
normalize(_colorSal, _colorSal, 0, 1, NORM_MINMAX, CV_32F);
}
// Find similar colors & Smooth saliency value for color bins
vector<vector<CostfIdx>> similar(binN); // Similar color: how similar and their index
Vec3f* color = (Vec3f*)(binColor3f.data);
cvtColor(binColor3f, binColor3f, CV_BGR2Lab);
for (int i = 0; i < binN; i++){
vector<CostfIdx> &similari = similar[i];
similari.push_back(make_pair(0.f, i));
for (int j = 0; j < binN; j++)
if (i != j)
similari.push_back(make_pair(vecDist<float, 3>(color[i], color[j]), j));
sort(similari.begin(), similari.end());
}
cvtColor(binColor3f, binColor3f, CV_Lab2BGR);
//CmShow::HistBins(binColor3f, _colorSal, "BeforeSmooth", true);
SmoothSaliency(colorNums1i, _colorSal, delta, similar);
//CmShow::HistBins(binColor3f, _colorSal, "AfterSmooth", true);
// Reassign pixel saliency values
float* colorSal = (float*)(_colorSal.data);
for (int y = 0; y < rows; y++){
const int* idx = idx1i.ptr<int>(y);
float* resSal = sal1f.ptr<float>(y);
for (int x = 0; x < cols; x++)
resSal[x] = colorSal[idx[x]];
}
//imshow("After", sal1f);
//waitKey(0);
}
void mainQ(const TBlocks *input, TBlocks *output)
{
// Y1
Quantize((int*)(*input).Y1.pixel, LuminanceQTable.QCoef);
ZigzagMatrix((int*)(*input).Y1.pixel, (*output).Y1.pixel);
// Y2
Quantize((int*)(*input).Y2.pixel, LuminanceQTable.QCoef);
ZigzagMatrix((int*)(*input).Y2.pixel, (*output).Y2.pixel);
// U1
Quantize((int*)(*input).U1.pixel, ChrominanceQTable.QCoef);
ZigzagMatrix((int*)(*input).U1.pixel, (*output).U1.pixel);
// V1
Quantize((int*)(*input).V1.pixel, ChrominanceQTable.QCoef);
ZigzagMatrix((int*)(*input).V1.pixel, (*output).V1.pixel);
}
void AxisSweep3::UpdateHandle(unsigned short handle, const SimdPoint3& aabbMin,const SimdPoint3& aabbMax)
{
// assert(bounds.IsFinite());
//assert(bounds.HasVolume());
Handle* pHandle = GetHandle(handle);
// quantize the new bounds
unsigned short min[3], max[3];
Quantize(min, aabbMin, 0);
Quantize(max, aabbMax, 1);
// update changed edges
for (int axis = 0; axis < 3; axis++)
{
unsigned short emin = pHandle->m_minEdges[axis];
unsigned short emax = pHandle->m_maxEdges[axis];
int dmin = (int)min[axis] - (int)m_pEdges[axis][emin].m_pos;
int dmax = (int)max[axis] - (int)m_pEdges[axis][emax].m_pos;
m_pEdges[axis][emin].m_pos = min[axis];
m_pEdges[axis][emax].m_pos = max[axis];
// expand (only adds overlaps)
if (dmin < 0)
SortMinDown(axis, emin);
if (dmax > 0)
SortMaxUp(axis, emax);
// shrink (only removes overlaps)
if (dmin > 0)
SortMinUp(axis, emin);
if (dmax < 0)
SortMaxDown(axis, emax);
}
//PrintAxis(1);
}
/**
* Compresses the raw lightmap data to a buffer for writing over Swarm
*/
void FLightMapData2D::Compress(int32 DebugSampleIndex)
{
// make sure the data has been quantized already
Quantize(DebugSampleIndex);
// calculate the uncompressed size
UncompressedDataSize = sizeof(FQuantizedLightSampleData) * QuantizedData.Num();
// compress the array
CompressData((uint8*)QuantizedData.GetData(), UncompressedDataSize, CompressedData, CompressedDataSize);
// we no longer need the source data now that we're compressed
QuantizedData.Empty();
}
void FSignedDistanceFieldShadowMapData2D::Compress(int32 DebugSampleIndex)
{
// Make sure the data has been quantized already
Quantize(DebugSampleIndex);
// Calculate the uncompressed size
UncompressedDataSize = sizeof(FQuantizedSignedDistanceFieldShadowSampleData) * QuantizedData.Num();
// Compress the array
CompressData((uint8*)QuantizedData.GetData(), UncompressedDataSize, CompressedData, CompressedDataSize);
// Discard the source data now that we're compressed
QuantizedData.Empty();
}
/*++
* @name DynamicLoadIcon
*
* Returns the respective icon as per the current battery capacity.
* It also does the work of setting global parameters of battery capacity and tooltips.
*
* @param hinst
* A handle to a instance of the module.
*
* @return The handle to respective battery icon.
*
*--*/
static HICON DynamicLoadIcon(HINSTANCE hinst)
{
SYSTEM_POWER_STATUS PowerStatus;
HICON hBatIcon;
UINT index = -1;
if (!GetSystemPowerStatus(&PowerStatus) ||
PowerStatus.ACLineStatus == AC_LINE_UNKNOWN ||
PowerStatus.BatteryFlag == BATTERY_FLAG_UNKNOWN)
{
hBatIcon = LoadIcon(hinst, MAKEINTRESOURCE(IDI_BATTCAP_ERR));
g_strTooltip.LoadStringW(IDS_PWR_UNKNOWN_REMAINING);
return hBatIcon;
}
if (((PowerStatus.BatteryFlag & BATTERY_FLAG_NO_BATTERY) == 0) &&
((PowerStatus.BatteryFlag & BATTERY_FLAG_CHARGING) == BATTERY_FLAG_CHARGING))
{
index = Quantize(PowerStatus.BatteryLifePercent);
hBatIcon = LoadIcon(hinst, MAKEINTRESOURCE(bc_icons[index]));
g_strTooltip.Format(IDS_PWR_CHARGING, PowerStatus.BatteryLifePercent);
}
else if (((PowerStatus.BatteryFlag & BATTERY_FLAG_NO_BATTERY) == 0) &&
((PowerStatus.BatteryFlag & BATTERY_FLAG_CHARGING) == 0))
{
index = Quantize(PowerStatus.BatteryLifePercent);
hBatIcon = LoadIcon(hinst, MAKEINTRESOURCE(br_icons[index]));
g_strTooltip.Format(IDS_PWR_PERCENT_REMAINING, PowerStatus.BatteryLifePercent);
}
else
{
hBatIcon = LoadIcon(hinst, MAKEINTRESOURCE(IDI_POWER_AC));
g_strTooltip.LoadStringW(IDS_PWR_AC);
}
return hBatIcon;
}
//////////////////////////////////////////////////////////////////////////
// High level control
void CMotionDef::Load(IReader* MP, u32 fl, u16 version)
{
// params
bone_or_part= MP->r_u16(); // bCycle?part_id:bone_id;
motion = MP->r_u16(); // motion_id
speed = Quantize(MP->r_float());
power = Quantize(MP->r_float());
accrue = Quantize(MP->r_float());
falloff = Quantize(MP->r_float());
flags = (u16)fl;
if (!(flags&esmFX) && (falloff>=accrue)) falloff = u16(accrue-1);
if(version>=4)
{
u32 cnt = MP->r_u32();
if(cnt>0)
{
marks.resize (cnt);
for(u32 i=0; i<cnt; ++i)
marks[i].Load (MP);
}
}
}
dgInt32 dgCollisionConvexHull::CalculateSignature (dgInt32 vertexCount, const dgFloat32* const vertexArray, dgInt32 strideInBytes)
{
dgStack<dgUnsigned32> buffer(1 + 3 * vertexCount);
dgInt32 stride = dgInt32 (strideInBytes / sizeof (dgFloat32));
memset (&buffer[0], 0, size_t (buffer.GetSizeInBytes()));
buffer[0] = m_convexHullCollision;
for (dgInt32 i = 0; i < vertexCount; i ++) {
buffer[1 + i * 3 + 0] = dgCollision::Quantize (vertexArray[i * stride + 0]);
buffer[1 + i * 3 + 1] = dgCollision::Quantize (vertexArray[i * stride + 1]);
buffer[1 + i * 3 + 2] = dgCollision::Quantize (vertexArray[i * stride + 2]);
}
return Quantize(&buffer[0], buffer.GetSizeInBytes());
}
// used by ArrowGetAlpha and ArrowGetGlow below
float ArrowGetPercentVisible( const PlayerState* pPlayerState, int iCol, float fYOffset, float fYReverseOffsetPixels )
{
/* Get the YPos without reverse (that is, factor in EFFECT_TIPSY). */
float fYPos = ArrowEffects::GetYPos( pPlayerState, iCol, fYOffset, fYReverseOffsetPixels, false );
const float fDistFromCenterLine = fYPos - GetCenterLine( pPlayerState );
if( fYPos < 0 ) // past Gray Arrows
return 1; // totally visible
const float* fAppearances = pPlayerState->m_CurrentPlayerOptions.m_fAppearances;
float fVisibleAdjust = 0;
if( fAppearances[PlayerOptions::APPEARANCE_HIDDEN] != 0 )
{
float fHiddenVisibleAdjust = SCALE( fYPos, GetHiddenStartLine(pPlayerState), GetHiddenEndLine(pPlayerState), 0, -1 );
CLAMP( fHiddenVisibleAdjust, -1, 0 );
fVisibleAdjust += fAppearances[PlayerOptions::APPEARANCE_HIDDEN] * fHiddenVisibleAdjust;
}
if( fAppearances[PlayerOptions::APPEARANCE_SUDDEN] != 0 )
{
float fSuddenVisibleAdjust = SCALE( fYPos, GetSuddenStartLine(pPlayerState), GetSuddenEndLine(pPlayerState), -1, 0 );
CLAMP( fSuddenVisibleAdjust, -1, 0 );
fVisibleAdjust += fAppearances[PlayerOptions::APPEARANCE_SUDDEN] * fSuddenVisibleAdjust;
}
if( fAppearances[PlayerOptions::APPEARANCE_STEALTH] != 0 )
fVisibleAdjust -= fAppearances[PlayerOptions::APPEARANCE_STEALTH];
if( fAppearances[PlayerOptions::APPEARANCE_BLINK] != 0 )
{
float f = RageFastSin(RageTimer::GetTimeSinceStartFast()*10);
f = Quantize( f, 0.3333f );
fVisibleAdjust += SCALE( f, 0, 1, -1, 0 );
}
if( fAppearances[PlayerOptions::APPEARANCE_RANDOMVANISH] != 0 )
{
const float fRealFadeDist = 80;
fVisibleAdjust += SCALE( fabsf(fDistFromCenterLine), fRealFadeDist, 2*fRealFadeDist, -1, 0 )
* fAppearances[PlayerOptions::APPEARANCE_RANDOMVANISH];
}
return clamp( 1+fVisibleAdjust, 0, 1 );
}
Mat CmSaliencyRC::GetHC(CMat &img3f)
{
// Quantize colors and
Mat idx1i, binColor3f, colorNums1i, _colorSal;
Quantize(img3f, idx1i, binColor3f, colorNums1i);
cvtColor(binColor3f, binColor3f, CV_BGR2Lab);
GetHC(binColor3f, colorNums1i, _colorSal);
float* colorSal = (float*)(_colorSal.data);
Mat salHC1f(img3f.size(), CV_32F);
for (int r = 0; r < img3f.rows; r++){
float* salV = salHC1f.ptr<float>(r);
int* _idx = idx1i.ptr<int>(r);
for (int c = 0; c < img3f.cols; c++)
salV[c] = colorSal[_idx[c]];
}
GaussianBlur(salHC1f, salHC1f, Size(3, 3), 0);
normalize(salHC1f, salHC1f, 0, 1, NORM_MINMAX);
return salHC1f;
}
// used by ArrowGetAlpha and ArrowGetGlow below
float ArrowGetPercentVisible(float fYPosWithoutReverse)
{
const float fDistFromCenterLine = fYPosWithoutReverse - GetCenterLine();
if( fYPosWithoutReverse < 0 && HIDDEN_SUDDEN_PAST_RECEPTOR) // past Gray Arrows
return 1; // totally visible
const float* fAppearances = curr_options->m_fAppearances;
float fVisibleAdjust = 0;
if( fAppearances[PlayerOptions::APPEARANCE_HIDDEN] != 0 )
{
float fHiddenVisibleAdjust = SCALE( fYPosWithoutReverse, GetHiddenStartLine(), GetHiddenEndLine(), 0, -1 );
CLAMP( fHiddenVisibleAdjust, -1, 0 );
fVisibleAdjust += fAppearances[PlayerOptions::APPEARANCE_HIDDEN] * fHiddenVisibleAdjust;
}
if( fAppearances[PlayerOptions::APPEARANCE_SUDDEN] != 0 )
{
float fSuddenVisibleAdjust = SCALE( fYPosWithoutReverse, GetSuddenStartLine(), GetSuddenEndLine(), -1, 0 );
CLAMP( fSuddenVisibleAdjust, -1, 0 );
fVisibleAdjust += fAppearances[PlayerOptions::APPEARANCE_SUDDEN] * fSuddenVisibleAdjust;
}
if( fAppearances[PlayerOptions::APPEARANCE_STEALTH] != 0 )
fVisibleAdjust -= fAppearances[PlayerOptions::APPEARANCE_STEALTH];
if( fAppearances[PlayerOptions::APPEARANCE_BLINK] != 0 )
{
float f = RageFastSin(RageTimer::GetTimeSinceStartFast()*10);
f = Quantize( f, BLINK_MOD_FREQUENCY );
fVisibleAdjust += SCALE( f, 0, 1, -1, 0 );
}
if( fAppearances[PlayerOptions::APPEARANCE_RANDOMVANISH] != 0 )
{
const float fRealFadeDist = 80;
fVisibleAdjust += SCALE( fabsf(fDistFromCenterLine), fRealFadeDist, 2*fRealFadeDist, -1, 0 )
* fAppearances[PlayerOptions::APPEARANCE_RANDOMVANISH];
}
return clamp( 1+fVisibleAdjust, 0, 1 );
}
Mat CmSaliencyRC::GetRC(CMat &img3f, CMat ®Idx1i, int regNum, double sigmaDist)
{
Mat colorIdx1i, regSal1v, tmp, color3fv;
int QuatizeNum = Quantize(img3f, colorIdx1i, color3fv, tmp);
if (QuatizeNum == 2){
printf("QuatizeNum == 2, %d: %s\n", __LINE__, __FILE__);
Mat sal;
compare(colorIdx1i, 1, sal, CMP_EQ);
sal.convertTo(sal, CV_32F, 1.0/255);
return sal;
}
if (QuatizeNum <= 2) // Color quantization
return Mat::zeros(img3f.size(), CV_32F);
cvtColor(color3fv, color3fv, CV_BGR2Lab);
vector<Region> regs(regNum);
BuildRegions(regIdx1i, regs, colorIdx1i, color3fv.cols);
RegionContrast(regs, color3fv, regSal1v, sigmaDist);
Mat sal1f = Mat::zeros(img3f.size(), CV_32F);
cv::normalize(regSal1v, regSal1v, 0, 1, NORM_MINMAX, CV_32F);
float* regSal = (float*)regSal1v.data;
for (int r = 0; r < img3f.rows; r++){
const int* regIdx = regIdx1i.ptr<int>(r);
float* sal = sal1f.ptr<float>(r);
for (int c = 0; c < img3f.cols; c++)
sal[c] = regSal[regIdx[c]];
}
Mat bdReg1u = GetBorderReg(regIdx1i, regNum, 0.02, 0.4);
sal1f.setTo(0, bdReg1u);
SmoothByHist(img3f, sal1f, 0.1f);
SmoothByRegion(sal1f, regIdx1i, regNum);
sal1f.setTo(0, bdReg1u);
GaussianBlur(sal1f, sal1f, Size(3, 3), 0);
return sal1f;
}
