Vector3 Discretize(const Vector3& value,const Vector3& resolution,const Vector3& variance)
{
Vector3 res;
res.x = Discretize(value.x,resolution.x,variance.x);
res.y = Discretize(value.y,resolution.y,variance.y);
res.z = Discretize(value.z,resolution.z,variance.z);
return res;
}
// The core function that returns the answer of the problem (find the time to the ground)
int GetTime() {
// sort
std::sort(segment_, segment_+size_, HeightCompare);
// discretization:
Discretize();
Construct(1, 0, pos_num_);
// dp, segment_[0] as ground
for (int i=1; i<size_; ++i) {
int l = GetSeg(1, segment_[i].l);
int r = GetSeg(1, segment_[i].r);
if (d_<segment_[i].y-segment_[l].y && d_<segment_[i].y-segment_[r].y) continue;
if ((!(d_<segment_[i].y-segment_[l].y)) && (!(d_<segment_[i].y-segment_[r].y))) {
segment_[i].t1 = GetTimeToSeg(segment_[i].x1, segment_[i].y, l);
segment_[i].t2 = GetTimeToSeg(segment_[i].x2, segment_[i].y, r);
segment_[i].t1 = std::min(segment_[i].t1, segment_[i].t2+segment_[i].x2-segment_[i].x1);
segment_[i].t2 = std::min(segment_[i].t2, segment_[i].t1+segment_[i].x2-segment_[i].x1);
} else if (!(d_<segment_[i].y-segment_[l].y)) {
segment_[i].t1 = GetTimeToSeg(segment_[i].x1, segment_[i].y, l);
segment_[i].t2 = segment_[i].t1+segment_[i].x2-segment_[i].x1;
} else if (!(d_<segment_[i].y-segment_[r].y)) {
segment_[i].t2 = GetTimeToSeg(segment_[i].x2, segment_[i].y, r);
segment_[i].t1 = segment_[i].t2+segment_[i].x2-segment_[i].x1;
}
Update(1, segment_[i].l, segment_[i].r, i);
}
return GetTimeToSeg(x_, y_, GetSeg(1, pos_));
}
std::vector<unsigned int> HashTable::FindNN(TVector2 position) {
std::vector<unsigned int> results;
std::vector<unsigned int> cell;
TVector2 min = Discretize(position) - TVector2(_NG_H_,_NG_H_);
TVector2 max = Discretize(position) + TVector2(_NG_H_,_NG_H_);
for(TVector2 it(min); it.X() <= max.X() ; it.Set(it.X()+1,it.Y())) {
for(it.Set(it.X(),min.Y());it.Y() <= max.Y(); it.Set(it.X(),it.Y()+1)) {
cell.clear();
cell = hashTable[GetHash(it)];
results.insert(results.end(), cell.begin(), cell.end());
}
}
return results;
}
//---------------------------------------------------------
bool CSG_mRMR::Set_Data(CSG_Table &Data, int ClassField, double Threshold)
{
if( !Get_Memory(Data.Get_Field_Count(), Data.Get_Count()) )
{
return( false );
}
//-----------------------------------------------------
if( ClassField < 0 || ClassField >= m_nVars )
{
ClassField = 0;
}
Data.Set_Index(ClassField, TABLE_INDEX_Ascending);
CSG_String s;
for(int iSample=0, Class=0; iSample<m_nSamples; iSample++)
{
double *pData = m_Samples[iSample] = m_Samples[0] + iSample * m_nVars;
if( s.Cmp(Data[iSample].asString(ClassField)) )
{
s = Data[iSample].asString(ClassField);
Class++;
}
*pData++ = Class;
for(int iVar=0; iVar<m_nVars; iVar++)
{
if( iVar != ClassField )
{
*pData++ = Data[iSample].asDouble(iVar);
}
}
}
Data.Del_Index();
m_VarNames += Data.Get_Field_Name(ClassField);
for(int iVar=0; iVar<m_nVars; iVar++)
{
if( iVar != ClassField )
{
m_VarNames += Data.Get_Field_Name(iVar);
}
}
//-----------------------------------------------------
if( Threshold >= 0.0 ) // discretization
{
Discretize(Threshold);
}
return( true );
}
//---------------------------------------------------------
bool CSG_mRMR::Set_Data(CSG_Matrix &Data, int ClassField, double Threshold)
{
if( !Get_Memory(Data.Get_NCols(), Data.Get_NRows()) )
{
return( false );
}
//-----------------------------------------------------
if( ClassField < 0 || ClassField >= m_nVars )
{
ClassField = 0;
}
for(int iSample=0; iSample<m_nSamples; iSample++)
{
double *pData = m_Samples[iSample] = m_Samples[0] + iSample * m_nVars;
*pData++ = Data[iSample][ClassField];
for(int iVar=0; iVar<m_nVars; iVar++)
{
if( iVar != ClassField )
{
*pData++ = Data[iSample][iVar];
}
}
}
m_VarNames += "CLASS";
for(int iVar=0; iVar<m_nVars; iVar++)
{
if( iVar != ClassField )
{
m_VarNames += CSG_String::Format(SG_T("FEATURE_%02d"), iVar);
}
}
//-----------------------------------------------------
if( Threshold >= 0.0 ) // discretization
{
Discretize(Threshold);
}
return( true );
}
void HashTable::Add(unsigned int i, TVector2 position) {
position = Discretize(position);
hashTable[GetHash(position)].push_back(i);
}
